@webda/graphql 4.0.0-beta.2 → 4.0.0-beta.3

package/lib/graphql.spec.js

@@ -1,669 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { suite, test } from "@testdeck/mocha";
-import { FileBinary, HttpContext, SecureCookie, Service, WebdaError, getCommonJS } from "@webda/core";
-import { WebdaTest } from "@webda/core/lib/test.js";
-import { ServerStatus, WebdaServer } from "@webda/shell";
-import { WebdaSampleApplication } from "@webda/shell/lib/index.spec.js";
-import * as assert from "assert";
-import { Kind } from "graphql";
-import { createClient } from "graphql-ws";
-import * as path from "path";
-import WebSocket from "ws";
-import { GraphQLService } from "./graphql.js";
-import { AnyScalarType } from "./types/any.js";
-import { DateScalar } from "./types/date.js";
-import { GraphQLLong } from "./types/long.js";
-const { __dirname } = getCommonJS(import.meta.url);
-class MyWebSocket extends WebSocket {
-    constructor(address, protocols) {
-        super(address, protocols, {
-            headers: MyWebSocket.headers
-        });
-    }
-}
-MyWebSocket.headers = {};
-class FakeService extends Service {
-    getClientEvents() {
-        return ["test", "test2"];
-    }
-    authorizeClientEvent(_event, _context) {
-        return true;
-    }
-}
-let GraphQLServiceTest = class GraphQLServiceTest extends WebdaTest {
-    async before() {
-        await super.before();
-        await this.registerService(new FileBinary(this.webda, "filebinary", { folder: "./test/binaries", models: { "*": ["*"] } }));
-        this.service = await this.registerService(new GraphQLService(this.webda, "graphql")).resolve().init();
-    }
-    getTestConfiguration() {
-        return path.resolve(`${__dirname}/../../../sample-app/`);
-    }
-    async createLocalGraphObjects() {
-        const Teacher = this.webda.getModel("Teacher");
-        const Company = this.webda.getModel("Company");
-        const User = this.webda.getModel("User");
-        let i = 1;
-        // 2 Teachers
-        await Teacher.create({ name: "test" });
-        await Teacher.create({ name: "test2" });
-        // 2 Companies
-        const companies = [await Company.create({ name: "company 1" }), await Company.create({ name: "company 2" })];
-        const users = [];
-        for (const conpany of companies) {
-            users.push(await User.create({
-                name: `User ${i++}`,
-                _company: conpany.uuid
-            }));
-        }
-        return { companies, users };
-    }
-    async query() {
-        const { users } = await this.createLocalGraphObjects();
-        let q = `{ Teachers(query:"") { results { name, _lastUpdate, uuid } }, Teacher(uuid:"test") { name } }`;
-        let result = await this.http({
-            method: "POST",
-            url: "/graphql",
-            body: `{"query": "${q.replace(/"/g, '\\"')}"}`,
-            headers: {
-                "content-type": "application/json; charset=utf-8"
-            }
-        });
-        assert.strictEqual(result.data.Teachers.results.length, 0);
-        assert.strictEqual(result.errors[0].message, "Object not found");
-        const context = await this.newContext();
-        context.getSession().login("test", "test");
-        result = await this.http({
-            method: "POST",
-            url: "/graphql",
-            body: `{"query": "${q.replace(/"/g, '\\"')}"}`,
-            headers: {
-                "content-type": "application/json; charset=utf-8"
-            },
-            context
-        });
-        assert.strictEqual(result.data.Teachers.results.length, 2);
-        const uuid = result.data.Teachers.results[0].uuid;
-        q = `{ Teacher(uuid:"${uuid}") { name } }`;
-        result = await this.http({
-            method: "POST",
-            url: "/graphql",
-            body: `{"query": "${q.replace(/"/g, '\\"')}"}`,
-            headers: {
-                "content-type": "application/json; charset=utf-8"
-            }
-        });
-        assert.strictEqual(result.errors[0].message, "Permission denied");
-        context.getSession().login("test", "test");
-        q = `{ Teacher(uuid:"${uuid}") { name } }`;
-        result = await this.http({
-            method: "POST",
-            url: "/graphql",
-            body: `{"query": "${q.replace(/"/g, '\\"')}"}`,
-            headers: {
-                "content-type": "application/json; charset=utf-8"
-            },
-            context
-        });
-        assert.strictEqual(result.errors, undefined);
-        assert.strictEqual(result.data.Teacher.name, "test");
-        q = `{ Companies { results { name, users { results { name } } } } }`;
-        result = await this.http({
-            method: "POST",
-            url: "/graphql",
-            body: `{"query": "${q.replace(/"/g, '\\"')}"}`,
-            headers: {
-                "content-type": "application/json; charset=utf-8"
-            },
-            context
-        });
-        assert.strictEqual(result.errors, undefined);
-        context.getSession().login(users[1].uuid, users[1].uuid);
-        q = `{ Me { name, computers { results { name } } } }`;
-        result = await this.http({
-            method: "POST",
-            url: "/graphql",
-            body: `{"query": "${q.replace(/"/g, '\\"')}"}`,
-            headers: {
-                "content-type": "application/json; charset=utf-8"
-            },
-            context
-        });
-        assert.notStrictEqual(result.data.Me.computers, undefined);
-    }
-    async coreGraph() {
-        await this.createGraphObjects();
-        const context = await this.newContext();
-        context.getSession().login("test", "test");
-        let q = `{ Courses { results { uuid, name, teacher { name, uuid }, classroom { name, uuid }, students { email } } } }`;
-        let result = await this.http({
-            method: "POST",
-            url: "/graphql",
-            body: `{"query": "${q.replace(/"/g, '\\"')}"}`,
-            headers: {
-                "content-type": "application/json; charset=utf-8"
-            },
-            context
-        });
-        // Expect some errors for Too many operations
-        assert.strictEqual(result.errors.filter(err => err.message === "Too many operations").length, 14);
-        this.service.getParameters().maxOperationsPerRequest = 30;
-        result = await this.http({
-            method: "POST",
-            url: "/graphql",
-            body: `{"query": "${q.replace(/"/g, '\\"')}"}`,
-            headers: {
-                "content-type": "application/json; charset=utf-8"
-            },
-            context
-        });
-        assert.strictEqual(context.getExtension("graphql").count, 24);
-        q = `{ Courses { results { uuid, students(filter:"email LIKE '%4%'") { email } } } }`;
-        result = await this.http({
-            method: "POST",
-            url: "/graphql",
-            body: `{"query": "${q.replace(/"/g, '\\"')}"}`,
-            headers: {
-                "content-type": "application/json; charset=utf-8"
-            },
-            context
-        });
-        assert.strictEqual(result.data.Courses.results.map(c => c.students).filter(i => i.length > 0).length, 8);
-        q = `{ Courses { results { uuid, students(filter:"order > 7 AND email LIKE '%webda.io'") { email } } } }`;
-        result = await this.http({
-            method: "POST",
-            url: "/graphql",
-            body: `{"query": "${q.replace(/"/g, '\\"')}"}`,
-            headers: {
-                "content-type": "application/json; charset=utf-8"
-            },
-            context
-        });
-        assert.strictEqual(result.data.Courses.results.map(c => c.students).filter(i => i !== null && i.length > 0).length, 4);
-        const course = result.data.Courses.results[0];
-        q = `{ Course(uuid: "${course.uuid}") {  classroom { uuid, name, courses { uuid },  hardwares { results { uuid, classroom { uuid } } } } } }`;
-        result = await this.http({
-            method: "POST",
-            url: "/graphql",
-            body: `{"query": "${q.replace(/"/g, '\\"')}"}`,
-            headers: {
-                "content-type": "application/json; charset=utf-8"
-            },
-            context
-        });
-    }
-    async graphiql() {
-        this.service.getParameters().exposeGraphiQL = true;
-        let body = await this.http({
-            url: "/graphql",
-            headers: {
-                "content-type": "application/json; charset=utf-8"
-            }
-        });
-        assert.ok(body.includes("graphiql.min.js"), "Should contain graphiql");
-        // Ensure {{URL}} is replaced
-        assert.ok(body.includes("http://test.webda.io/graphql"), "Should contain graphiql");
-        body = await this.http({
-            url: "/graphql",
-            headers: {
-                "content-type": "application/json; charset=utf-8",
-                "X-GraphiQL-Schema": "true"
-            }
-        });
-        assert.ok(body.includes("type Query"), "Should contain schema");
-        assert.ok(body.match(/type Query {[\w\W]*Teacher\(uuid: String\): Teacher[\w\W]*Me: User[\w\W]*}/gm), "Should contain schema");
-        // Check schema is retrieved
-        this.service.getParameters().exposeGraphiQL = false;
-        // Check for Companies and Company
-        await assert.rejects(() => this.http({
-            url: "/graphql",
-            headers: {
-                "content-type": "application/json; charset=utf-8"
-            }
-        }), WebdaError.NotFound);
-    }
-    async mutations() {
-        const context = await this.newContext();
-        // Test successfull creation and update
-        context.getSession().login("test", "test");
-        const Classroom = this.webda.getModel("Classroom");
-        let result = await this.http({
-            method: "POST",
-            url: "/graphql",
-            body: `{"query":"mutation createClassroom($classroom:ClassroomInput) { createClassroom(Classroom:$classroom) {    name    uuid  }}","variables":{"classroom":{"name":"test","uuid":"test"}},"operationName":"createClassroom"}`,
-            headers: {
-                "content-type": "application/json; charset=utf-8"
-            },
-            context
-        });
-        assert.ok(await Classroom.ref("test").exists());
-        result = await this.http({
-            method: "POST",
-            url: "/graphql",
-            body: `{"query":"mutation updateClassroom($classroom:ClassroomInput) { updateClassroom(Classroom:$classroom, uuid:\\"test\\") {    name    _lastUpdate  }}","variables":{"classroom":{"name":"test2"}},"operationName":"updateClassroom"}`,
-            headers: {
-                "content-type": "application/json; charset=utf-8"
-            },
-            context
-        });
-        assert.strictEqual((await Classroom.ref("test").get()).name, "test2");
-        // test2 user should not be able to do anything on Classroom
-        context.getSession().login("test2", "test2");
-        result = await this.http({
-            method: "POST",
-            url: "/graphql",
-            body: `{"query":"mutation createClassroom($classroom:ClassroomInput) { createClassroom(Classroom:$classroom) {    name    uuid  }}","variables":{"classroom":{"name":"test2","uuid":"test2"}},"operationName":"createClassroom"}`,
-            headers: {
-                "content-type": "application/json; charset=utf-8"
-            },
-            context
-        });
-        assert.ok(!(await this.webda.getModel("Course").ref("test2").exists()));
-        result = await this.http({
-            method: "POST",
-            url: "/graphql",
-            body: `{"query":"mutation updateClassroom($classroom:ClassroomInput) { updateClassroom(Classroom:$classroom, uuid:\\"test\\") {    name    _lastUpdate  }}","variables":{"classroom":{"name":"test3"}},"operationName":"updateClassroom"}`,
-            headers: {
-                "content-type": "application/json; charset=utf-8"
-            },
-            context
-        });
-        assert.strictEqual((await Classroom.ref("test").get()).name, "test2");
-        result = await this.http({
-            method: "POST",
-            url: "/graphql",
-            body: `{"query":"mutation deleteClassroom($uuid:String) { deleteClassroom(uuid:$uuid) {    success  }}","variables":{"uuid":"test"},"operationName":"deleteClassroom"}`,
-            headers: {
-                "content-type": "application/json; charset=utf-8"
-            },
-            context
-        });
-        assert.ok(await Classroom.ref("test").exists());
-        // Finally delete the test object
-        context.getSession().login("test", "test");
-        result = await this.http({
-            method: "POST",
-            url: "/graphql",
-            body: `{"query":"mutation deleteClassroom($uuid:String) { deleteClassroom(uuid:$uuid) {    success  }}","variables":{"uuid":"test"},"operationName":"deleteClassroom"}`,
-            headers: {
-                "content-type": "application/json; charset=utf-8"
-            },
-            context
-        });
-        assert.ok(!(await Classroom.ref("test").exists()));
-    }
-    async cov() {
-        this.service.app.addModel("WebdaDemo/User2", {
-            getSchema: () => undefined,
-            Expose: {
-                restrict: {},
-                root: true
-            },
-            getIdentifier: () => "WebdaDemo/User2",
-            getClientEvents: () => []
-        });
-        this.service.app.addModel("WebdaDemo/User3", {
-            getSchema: () => undefined,
-            Expose: {
-                restrict: {},
-                root: true
-            },
-            getIdentifier: () => "User3",
-            getClientEvents: () => []
-        });
-        this.service.app.addModel("WebdaDemo/Cov", {
-            getSchema: () => ({
-                type: "object",
-                properties: {
-                    name: {
-                        type: "object",
-                        properties: {
-                            name: {
-                                type: "null"
-                            }
-                        }
-                    }
-                }
-            }),
-            getUuidField: () => "uuid",
-            Expose: {
-                restrict: {},
-                root: true
-            },
-            getClientEvents: () => [],
-            getIdentifier: () => "WebdaDemo/Cov"
-        });
-        this.service.app.addModel("WebdaDemo/Cov2", {
-            getSchema: () => ({
-                type: "object",
-                properties: {
-                    name: {
-                        type: "array",
-                        items: {
-                            $ref: "#/definitions/plop"
-                        }
-                    }
-                },
-                definitions: {
-                    plop: {
-                        type: "string"
-                    }
-                }
-            }),
-            getUuidField: () => "uuid",
-            Expose: {
-                restrict: {},
-                root: true
-            },
-            getClientEvents: () => [],
-            getIdentifier: () => "WebdaDemo/Cov2"
-        });
-        this.service.getParameters().userModel = "User2";
-        this.service.getParameters()["excludedModels"].push("User3");
-        await this.service.resolve().init();
-        // Just for hitting the default GraphQLString
-        this.service.getGraphQLSchemaFromSchema({ type: "array", items: { type: "null" } }, "plop");
-    }
-};
-__decorate([
-    test
-], GraphQLServiceTest.prototype, "query", null);
-__decorate([
-    test
-], GraphQLServiceTest.prototype, "coreGraph", null);
-__decorate([
-    test
-], GraphQLServiceTest.prototype, "graphiql", null);
-__decorate([
-    test
-], GraphQLServiceTest.prototype, "mutations", null);
-__decorate([
-    test
-], GraphQLServiceTest.prototype, "cov", null);
-GraphQLServiceTest = __decorate([
-    suite
-], GraphQLServiceTest);
-let GraphQLSubscriptionTest = class GraphQLSubscriptionTest {
-    async subscriptions() {
-        let fake;
-        await WebdaSampleApplication.load();
-        WebdaSampleApplication.getConfiguration().services.graphql = {
-            type: "GraphQLService",
-            exposeMe: true
-        };
-        WebdaSampleApplication.getConfiguration().services.fake = {
-            type: "FakeService"
-        };
-        WebdaSampleApplication.addService("FakeService", FakeService);
-        const server = new WebdaServer(WebdaSampleApplication);
-        const Course = server.getModel("Course");
-        const User = server.getModel("WebdaDemo/User");
-        try {
-            await server.init();
-            fake = server.getService("fake");
-            await Course.store().__clean();
-            await Course.ref("test").getOrCreate({
-                name: "test"
-            });
-            server.serve(28080);
-            await server.waitForStatus(ServerStatus.Started);
-            const client = createClient({
-                url: "ws://localhost:28080/graphql",
-                webSocketImpl: MyWebSocket
-            });
-            // subscription for change
-            console.log("Starting subscription on Course(test)");
-            await (async () => {
-                const subscription = client.iterate({
-                    query: `subscription { Course(uuid:"test") { name uuid } }`
-                });
-                for await (const event of subscription) {
-                    const obj = event.data?.Course;
-                    if (obj === null) {
-                        break;
-                    }
-                    else if (obj.name === "test2") {
-                        Course.ref("test").delete();
-                    }
-                    else {
-                        Course.ref("test").patch({ name: "test2" });
-                    }
-                }
-            })();
-            // subscription for change on non-existing
-            console.log("Starting subscription on Course(test2)", await Course.ref("test2").get());
-            await (async () => {
-                const subscription = client.iterate({
-                    query: `subscription { Course(uuid:"test2") { name uuid } }`
-                });
-                for await (const event of subscription) {
-                }
-            })();
-            // subscription for new object
-            console.log("Starting subscription on Courses()");
-            await Course.ref("test").getOrCreate({
-                name: "test",
-                value: 10
-            });
-            await Course.ref("test2").getOrCreate({
-                name: "test2",
-                value: 10
-            });
-            let i = 0;
-            await (async () => {
-                const subscription = client.iterate({
-                    query: `subscription { Courses(query:"value=10") { results { name uuid } continuationToken } }`
-                });
-                // Test several use case
-                for await (const evt of subscription) {
-                    const event = evt;
-                    i++;
-                    if (i === 1) {
-                        // Update test2
-                        await Course.ref("test2").patch({ name: "test2b" });
-                    }
-                    else if (i === 2) {
-                        // Create test3
-                        assert.strictEqual(event.data?.Courses.results[1].name, "test2b");
-                        await Course.ref("test3").getOrCreate({ name: "test3", value: 10 });
-                        // This one should not trigger anything
-                        await Course.ref("test4").getOrCreate({ name: "test4", value: 1 });
-                    }
-                    else if (i === 3) {
-                        // Delete test
-                        assert.strictEqual(event.data?.Courses.results.length, 3);
-                        await Course.ref("test").delete();
-                    }
-                    else if (i === 4) {
-                        // Finishing the test
-                        assert.deepStrictEqual(event.data?.Courses.results.map(c => c.name), ["test2b", "test3"]);
-                        break;
-                    }
-                }
-            })();
-            // subscription for me
-            console.log("Starting subscription on Me w/o auth");
-            await (async () => {
-                const subscription = client.iterate({
-                    query: `subscription { Me { name } }`
-                });
-                for await (const event of subscription) {
-                    if (event) {
-                        break;
-                    }
-                }
-            })();
-            console.log("Starting subscription on MeEvents w/o auth");
-            await assert.rejects(async () => {
-                const subscription = client.iterate({
-                    query: `subscription { MeEvents { logout } }`
-                });
-                for await (const event of subscription) {
-                    if (event.errors) {
-                        throw event.errors[0];
-                    }
-                }
-            }, (err) => err.message === "Permission denied");
-            // Close client
-            await client.dispose();
-            // Test with a cookie
-            User.ref("test").create({ name: "plop" });
-            const ctx = await server.newWebContext(new HttpContext("test.webda.io", "GET", "/graphql"));
-            await SecureCookie.save("webda", ctx, { userId: "test" });
-            // Test with a cookie
-            MyWebSocket.headers.Cookie = `webda=${ctx._cookie["webda"].value}`;
-            const client2 = createClient({
-                url: "ws://localhost:28080/graphql",
-                webSocketImpl: MyWebSocket
-            });
-            i = 0;
-            console.log("Starting subscription on Me with auth");
-            await (async () => {
-                const subscription = client2.iterate({
-                    query: `subscription { Me { name } }`
-                });
-                for await (const evt of subscription) {
-                    const event = evt;
-                    i++;
-                    if (i === 1) {
-                        assert.strictEqual(event.data?.Me.name, "plop");
-                        await User.ref("test").patch({ name: "plop2" });
-                    }
-                    else if (i === 2) {
-                        assert.strictEqual(event.data?.Me.name, "plop2");
-                        break;
-                    }
-                }
-            })();
-            console.log("Starting subscription aggregation");
-            i = 0;
-            await (async () => {
-                const subscription = client2.iterate({
-                    //  Courses(query:"value=10") { name uuid } CoursesEvents(events:["test2"]) {  } CourseEvents(uuid:"test", events:["plop"]) {  }
-                    query: `subscription {  Aggregate { Me { name } Courses(query:"value=10") { results { name uuid } }  Course(uuid:"test2") { uuid name } CourseEvents(uuid:"test3") { test test4 } CoursesEvents { test2 } MeEvents { logout } } }`
-                });
-                for await (const evt of subscription) {
-                    const event = evt;
-                    i++;
-                    if (i === 1) {
-                        assert.strictEqual(event.data?.Aggregate.Me.name, "plop2");
-                        // Update test2
-                        await Course.ref("test2").patch({ name: "test2c" });
-                    }
-                    else if (i === 2) {
-                        // no-op
-                    }
-                    else if (i === 3) {
-                        await User.store().emitSync("logout", { test2: "test2", object_id: "test" });
-                    }
-                    else if (i === 4) {
-                        assert.ok(event.data?.Aggregate.Courses.results[0].name === "test2c" &&
-                            event.data?.Aggregate.Course.name === "test2c");
-                        assert.strictEqual(event.data?.Aggregate.MeEvents.logout?.test2, "test2");
-                        Course.store().emitSync("test", { object_id: "test3", type: "test1" });
-                    }
-                    else if (i === 5) {
-                        assert.deepStrictEqual(event.data.Aggregate.CourseEvents.test, {
-                            object_id: "test3",
-                            type: "test1"
-                        });
-                        Course.store().emitSync("test4", { object_id: "test3", type: "test4" });
-                    }
-                    else if (i === 6) {
-                        assert.deepStrictEqual(event.data.Aggregate.CourseEvents.test4, {
-                            object_id: "test3",
-                            type: "test4"
-                        });
-                        break;
-                    }
-                }
-            })();
-            console.log("Starting subscription aggregation with wrong permission");
-            i = 0;
-            await assert.rejects(async () => {
-                const subscription = client2.iterate({
-                    query: `subscription {  CourseEvents(uuid:"test") { test3 }  }`
-                });
-                for await (const evt of subscription) {
-                    if (evt.errors) {
-                        throw evt.errors[0];
-                    }
-                }
-            }, (err) => err.message === "Permission denied");
-            /* TODO Reenable
-            console.log("Starting subscription service");
-            i = 0;
-            await (async () => {
-              const subscription = client2.iterate({
-                //  Courses(query:"value=10") { name uuid } CoursesEvents(events:["test2"]) {  } CourseEvents(uuid:"test", events:["plop"]) {  }
-                query: `subscription { fakeEvents { test } }`
-              });
-              for await (const evt of subscription) {
-                const event: any = evt;
-                i++;
-                if (i === 1) {
-                  fake.emit("test", { test: "test" });
-                } else if (i === 2) {
-                  // no-op
-                  break;
-                }
-              }
-            })();
-            */
-        }
-        finally {
-            await Course.store().__clean();
-            await server.stop();
-        }
-    }
-};
-__decorate([
-    test
-], GraphQLSubscriptionTest.prototype, "subscriptions", null);
-GraphQLSubscriptionTest = __decorate([
-    suite
-], GraphQLSubscriptionTest);
-let TypesTest = class TypesTest {
-    any() {
-        const obj = { test: 1 };
-        AnyScalarType.parseValue(obj);
-        AnyScalarType.parseValue(JSON.stringify(obj));
-        AnyScalarType.parseLiteral({ kind: Kind.STRING, value: JSON.stringify(obj) });
-        assert.throws(() => AnyScalarType.parseLiteral({ kind: Kind.OBJECT }), /Not sure what to do with OBJECT for ObjectScalarType/);
-        assert.strictEqual(AnyScalarType.parseLiteral({ kind: Kind.BOOLEAN }), null);
-    }
-    long() {
-        GraphQLLong.parseValue("12344444");
-        assert.throws(() => GraphQLLong.parseValue(""));
-        assert.throws(() => GraphQLLong.parseValue("123456789012345678901234567890"), /Long cannot represent/);
-        assert.strictEqual(GraphQLLong.parseLiteral({ kind: Kind.BOOLEAN }), null);
-        assert.strictEqual(GraphQLLong.parseLiteral({ kind: Kind.INT, value: "−9007199254740992" }), null);
-        assert.strictEqual(GraphQLLong.parseLiteral({ kind: Kind.INT, value: "9007199254740992" }), null);
-        assert.strictEqual(GraphQLLong.parseLiteral({ kind: Kind.INT, value: "12345" }), 12345);
-    }
-    date() {
-        assert.ok(DateScalar.parseValue("2020-01-01T00:00:00.000Z") instanceof Date);
-        assert.throws(() => DateScalar.parseValue(12), /GraphQL Date Scalar parser expected a `string`/);
-        assert.throws(() => DateScalar.serialize("test"), /GraphQL Date Scalar serializer expected a `Date` object/);
-        assert.ok(DateScalar.parseLiteral({ kind: Kind.STRING, value: "2020-01-01T00:00:00.000Z" }) instanceof Date);
-        assert.strictEqual(DateScalar.parseLiteral({ kind: Kind.INT, value: "2020-01-01T00:00:00.000Z" }), null);
-    }
-};
-__decorate([
-    test
-], TypesTest.prototype, "any", null);
-__decorate([
-    test
-], TypesTest.prototype, "long", null);
-__decorate([
-    test
-], TypesTest.prototype, "date", null);
-TypesTest = __decorate([
-    suite
-], TypesTest);
-//# sourceMappingURL=graphql.spec.js.map