hono 1.2.2 → 1.3.2

package/dist/middleware/graphql-server/index.test.js

@@ -1,480 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const graphql_1 = require("graphql");
-const hono_1 = require("../../hono");
-const _1 = require(".");
-// Do not show `console.error` messages
-jest.spyOn(console, 'error').mockImplementation();
-describe('errorMessages', () => {
-    const messages = (0, _1.errorMessages)(['message a', 'message b']);
-    expect(messages).toEqual({
-        errors: [
-            {
-                message: 'message a',
-            },
-            {
-                message: 'message b',
-            },
-        ],
-    });
-});
-describe('GraphQL Middleware - Simple way', () => {
-    // Construct a schema, using GraphQL schema language
-    const schema = (0, graphql_1.buildSchema)(`
-  type Query {
-    hello: String
-  }
-`);
-    // The root provides a resolver function for each API endpoint
-    const rootValue = {
-        hello: () => 'Hello world!',
-    };
-    const app = new hono_1.Hono();
-    app.use('/graphql', (0, _1.graphqlServer)({
-        schema,
-        rootValue,
-    }));
-    it('Should return GraphQL response', async () => {
-        const query = 'query { hello }';
-        const body = {
-            query: query,
-        };
-        const res = await app.request('http://localhost/graphql', {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify(body),
-        });
-        expect(res).not.toBeNull();
-        expect(res.status).toBe(200);
-        expect(await res.text()).toBe('{"data":{"hello":"Hello world!"}}');
-    });
-});
-const QueryRootType = new graphql_1.GraphQLObjectType({
-    name: 'QueryRoot',
-    fields: {
-        test: {
-            type: graphql_1.GraphQLString,
-            args: {
-                who: { type: graphql_1.GraphQLString },
-            },
-            resolve: (_root, args) => { var _a; return 'Hello ' + ((_a = args.who) !== null && _a !== void 0 ? _a : 'World'); },
-        },
-        thrower: {
-            type: graphql_1.GraphQLString,
-            resolve() {
-                throw new Error('Throws!');
-            },
-        },
-    },
-});
-const TestSchema = new graphql_1.GraphQLSchema({
-    query: QueryRootType,
-    mutation: new graphql_1.GraphQLObjectType({
-        name: 'MutationRoot',
-        fields: {
-            writeTest: {
-                type: QueryRootType,
-                resolve: () => ({}),
-            },
-        },
-    }),
-});
-const urlString = (query) => {
-    const base = 'http://localhost/graphql';
-    if (!query)
-        return base;
-    const queryString = new URLSearchParams(query).toString();
-    return `${base}?${queryString}`;
-};
-describe('GraphQL Middleware - GET functionality', () => {
-    const app = new hono_1.Hono();
-    app.use('/graphql', (0, _1.graphqlServer)({
-        schema: TestSchema,
-    }));
-    it('Allows GET with variable values', async () => {
-        const query = {
-            query: 'query helloWho($who: String){ test(who: $who) }',
-            variables: JSON.stringify({ who: 'Dolly' }),
-        };
-        const res = await app.request(urlString(query), {
-            method: 'GET',
-        });
-        expect(res.status).toBe(200);
-        expect(await res.text()).toBe('{"data":{"test":"Hello Dolly"}}');
-    });
-    it('Allows GET with operation name', async () => {
-        const query = {
-            query: `
-        query helloYou { test(who: "You"), ...shared }
-        query helloWorld { test(who: "World"), ...shared }
-        query helloDolly { test(who: "Dolly"), ...shared }
-        fragment shared on QueryRoot {
-          shared: test(who: "Everyone")
-        }
-      `,
-            operationName: 'helloWorld',
-        };
-        const res = await app.request(urlString(query), {
-            method: 'GET',
-        });
-        expect(res.status).toBe(200);
-        expect(await res.json()).toEqual({
-            data: {
-                test: 'Hello World',
-                shared: 'Hello Everyone',
-            },
-        });
-    });
-    it('Reports validation errors', async () => {
-        const query = { query: '{ test, unknownOne, unknownTwo }' };
-        const res = await app.request(urlString(query), {
-            method: 'GET',
-        });
-        expect(res.status).toBe(400);
-    });
-    it('Errors when missing operation name', async () => {
-        const query = {
-            query: `
-          query TestQuery { test }
-          mutation TestMutation { writeTest { test } }
-        `,
-        };
-        const res = await app.request(urlString(query), {
-            method: 'GET',
-        });
-        expect(res.status).toBe(500);
-    });
-    it('Errors when sending a mutation via GET', async () => {
-        const query = {
-            query: 'mutation TestMutation { writeTest { test } }',
-        };
-        const res = await app.request(urlString(query), {
-            method: 'GET',
-        });
-        expect(res.status).toBe(405);
-    });
-    it('Errors when selecting a mutation within a GET', async () => {
-        const query = {
-            operationName: 'TestMutation',
-            query: `
-          query TestQuery { test }
-          mutation TestMutation { writeTest { test } }
-        `,
-        };
-        const res = await app.request(urlString(query), {
-            method: 'GET',
-        });
-        expect(res.status).toBe(405);
-    });
-    it('Allows a mutation to exist within a GET', async () => {
-        const query = {
-            operationName: 'TestQuery',
-            query: `
-          mutation TestMutation { writeTest { test } }
-          query TestQuery { test }
-        `,
-        };
-        const res = await app.request(urlString(query), {
-            method: 'GET',
-        });
-        expect(res.status).toBe(200);
-        expect(await res.json()).toEqual({
-            data: {
-                test: 'Hello World',
-            },
-        });
-    });
-});
-describe('GraphQL Middleware - POST functionality', () => {
-    const app = new hono_1.Hono();
-    app.use('/graphql', (0, _1.graphqlServer)({
-        schema: TestSchema,
-    }));
-    it('Allows POST with JSON encoding', async () => {
-        const query = { query: '{test}' };
-        const res = await app.request(urlString(), {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify(query),
-        });
-        expect(res.status).toBe(200);
-        expect(await res.text()).toBe('{"data":{"test":"Hello World"}}');
-    });
-    it('Allows sending a mutation via POST', async () => {
-        const query = { query: 'mutation TestMutation { writeTest { test } }' };
-        const res = await app.request(urlString(), {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify(query),
-        });
-        expect(res.status).toBe(200);
-        expect(await res.text()).toBe('{"data":{"writeTest":{"test":"Hello World"}}}');
-    });
-    it('Allows POST with url encoding', async () => {
-        const query = {
-            query: '{test}',
-        };
-        const res = await app.request(urlString(query), {
-            method: 'POST',
-        });
-        expect(res.status).toBe(200);
-        expect(await res.text()).toBe('{"data":{"test":"Hello World"}}');
-    });
-    it('Supports POST JSON query with string variables', async () => {
-        const query = {
-            query: 'query helloWho($who: String){ test(who: $who) }',
-            variables: JSON.stringify({ who: 'Dolly' }),
-        };
-        const res = await app.request(urlString(), {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify(query),
-        });
-        expect(res.status).toBe(200);
-        expect(await res.text()).toBe('{"data":{"test":"Hello Dolly"}}');
-    });
-    it('Supports POST url encoded query with string variables', async () => {
-        const searchParams = new URLSearchParams({
-            query: 'query helloWho($who: String){ test(who: $who) }',
-            variables: JSON.stringify({ who: 'Dolly' }),
-        });
-        const res = await app.request(urlString(), {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/x-www-form-urlencoded',
-            },
-            body: searchParams.toString(),
-        });
-        expect(res.status).toBe(200);
-        expect(await res.text()).toBe('{"data":{"test":"Hello Dolly"}}');
-    });
-    it('Supports POST JSON query with GET variable values', async () => {
-        const variables = {
-            variables: JSON.stringify({ who: 'Dolly' }),
-        };
-        const query = { query: 'query helloWho($who: String){ test(who: $who) }' };
-        const res = await app.request(urlString(variables), {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify(query),
-        });
-        expect(res.status).toBe(200);
-        expect(await res.text()).toBe('{"data":{"test":"Hello Dolly"}}');
-    });
-    it('Supports POST url encoded query with GET variable values', async () => {
-        const searchParams = new URLSearchParams({
-            query: 'query helloWho($who: String){ test(who: $who) }',
-        });
-        const variables = {
-            variables: JSON.stringify({ who: 'Dolly' }),
-        };
-        const res = await app.request(urlString(variables), {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/x-www-form-urlencoded',
-            },
-            body: searchParams.toString(),
-        });
-        expect(res.status).toBe(200);
-        expect(await res.text()).toBe('{"data":{"test":"Hello Dolly"}}');
-    });
-    it('Supports POST raw text query with GET variable values', async () => {
-        const variables = {
-            variables: JSON.stringify({ who: 'Dolly' }),
-        };
-        const res = await app.request(urlString(variables), {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/graphql',
-            },
-            body: 'query helloWho($who: String){ test(who: $who) }',
-        });
-        expect(res.status).toBe(200);
-        expect(await res.text()).toBe('{"data":{"test":"Hello Dolly"}}');
-    });
-    it('Allows POST with operation name', async () => {
-        const query = {
-            query: `
-        query helloYou { test(who: "You"), ...shared }
-        query helloWorld { test(who: "World"), ...shared }
-        query helloDolly { test(who: "Dolly"), ...shared }
-        fragment shared on QueryRoot {
-          shared: test(who: "Everyone")
-        }
-      `,
-            operationName: 'helloWorld',
-        };
-        const res = await app.request(urlString(), {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify(query),
-        });
-        expect(res.status).toBe(200);
-        expect(await res.json()).toEqual({
-            data: {
-                test: 'Hello World',
-                shared: 'Hello Everyone',
-            },
-        });
-    });
-    it('Allows POST with GET operation name', async () => {
-        const res = await app.request(urlString({
-            operationName: 'helloWorld',
-        }), {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/graphql',
-            },
-            body: `
-      query helloYou { test(who: "You"), ...shared }
-      query helloWorld { test(who: "World"), ...shared }
-      query helloDolly { test(who: "Dolly"), ...shared }
-      fragment shared on QueryRoot {
-        shared: test(who: "Everyone")
-      }
-    `,
-        });
-        expect(res.status).toBe(200);
-        expect(await res.json()).toEqual({
-            data: {
-                test: 'Hello World',
-                shared: 'Hello Everyone',
-            },
-        });
-    });
-});
-describe('Pretty printing', () => {
-    it('Supports pretty printing', async () => {
-        const app = new hono_1.Hono();
-        app.use('/graphql', (0, _1.graphqlServer)({
-            schema: TestSchema,
-            pretty: true,
-        }));
-        const res = await app.request(urlString({ query: '{test}' }));
-        expect(await res.text()).toEqual([
-            // Pretty printed JSON
-            '{',
-            '  "data": {',
-            '    "test": "Hello World"',
-            '  }',
-            '}',
-        ].join('\n'));
-    });
-});
-describe('Error handling functionality', () => {
-    const app = new hono_1.Hono();
-    app.use('/graphql', (0, _1.graphqlServer)({
-        schema: TestSchema,
-    }));
-    it('Handles query errors from non-null top field errors', async () => {
-        const schema = new graphql_1.GraphQLSchema({
-            query: new graphql_1.GraphQLObjectType({
-                name: 'Query',
-                fields: {
-                    test: {
-                        type: new graphql_1.GraphQLNonNull(graphql_1.GraphQLString),
-                        resolve() {
-                            throw new Error('Throws!');
-                        },
-                    },
-                },
-            }),
-        });
-        const app = new hono_1.Hono();
-        app.use('/graphql', (0, _1.graphqlServer)({ schema }));
-        const res = await app.request(urlString({
-            query: '{ test }',
-        }));
-        expect(res.status).toBe(500);
-    });
-    it('Handles syntax errors caught by GraphQL', async () => {
-        const res = await app.request(urlString({
-            query: 'syntax_error',
-        }), {
-            method: 'GET',
-        });
-        expect(res.status).toBe(400);
-    });
-    it('Handles errors caused by a lack of query', async () => {
-        const res = await app.request(urlString(), {
-            method: 'GET',
-        });
-        expect(res.status).toBe(400);
-    });
-    it('Handles invalid JSON bodies', async () => {
-        const res = await app.request(urlString(), {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify([]),
-        });
-        expect(res.status).toBe(400);
-    });
-    it('Handles incomplete JSON bodies', async () => {
-        const res = await app.request(urlString(), {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-            },
-            body: '{"query":',
-        });
-        expect(res.status).toBe(400);
-    });
-    it('Handles plain POST text', async () => {
-        const res = await app.request(urlString({
-            variables: JSON.stringify({ who: 'Dolly' }),
-        }), {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'text/plain',
-            },
-            body: 'query helloWho($who: String){ test(who: $who) }',
-        });
-        expect(res.status).toBe(400);
-    });
-    it('Handles poorly formed variables', async () => {
-        const res = await app.request(urlString({
-            variables: 'who:You',
-            query: 'query helloWho($who: String){ test(who: $who) }',
-        }), {
-            method: 'GET',
-        });
-        expect(res.status).toBe(400);
-    });
-    it('Handles invalid variables', async () => {
-        const res = await app.request(urlString(), {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify({
-                query: 'query helloWho($who: String){ test(who: $who) }',
-                variables: { who: ['John', 'Jane'] },
-            }),
-        });
-        expect(res.status).toBe(500);
-    });
-    it('Handles unsupported HTTP methods', async () => {
-        const res = await app.request(urlString({ query: '{test}' }), {
-            method: 'PUT',
-        });
-        expect(res.status).toBe(405);
-        expect(res.headers.get('allow')).toBe('GET, POST');
-        expect(await res.json()).toEqual({
-            errors: [{ message: 'GraphQL only supports GET and POST requests.' }],
-        });
-    });
-});

package/dist/middleware/graphql-server/parse-body.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/middleware/graphql-server/parse-body.test.js

@@ -1,57 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const parse_body_1 = require("./parse-body");
-describe('parseBody', () => {
-    it('Should return a blank JSON object', async () => {
-        const req = new Request('http://localhost/graphql');
-        const res = await (0, parse_body_1.parseBody)(req);
-        expect(res).toEqual({});
-    });
-    it('With Content-Type: application/graphql', async () => {
-        const req = new Request('http://localhost/graphql', {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/graphql',
-            },
-            body: 'query { hello }',
-        });
-        const res = await (0, parse_body_1.parseBody)(req);
-        expect(res).toEqual({ query: 'query { hello }' });
-    });
-    it('With Content-Type: application/json', async () => {
-        const variables = JSON.stringify({ who: 'Dolly' });
-        const req = new Request('http://localhost/graphql', {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify({
-                query: 'query { hello }',
-                variables: variables,
-            }),
-        });
-        const res = await (0, parse_body_1.parseBody)(req);
-        expect(res).toEqual({
-            query: 'query { hello }',
-            variables: variables,
-        });
-    });
-    it('With Content-Type: application/x-www-form-urlencoded', async () => {
-        const variables = JSON.stringify({ who: 'Dolly' });
-        const searchParams = new URLSearchParams();
-        searchParams.append('query', 'query { hello }');
-        searchParams.append('variables', variables);
-        const req = new Request('http://localhost/graphql', {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/x-www-form-urlencoded',
-            },
-            body: searchParams.toString(),
-        });
-        const res = await (0, parse_body_1.parseBody)(req);
-        expect(res).toEqual({
-            query: 'query { hello }',
-            variables: variables,
-        });
-    });
-});

package/dist/middleware/jwt/index.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/middleware/jwt/index.test.js

@@ -1,51 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const hono_1 = require("../../hono");
-const _1 = require(".");
-describe('Jwt Auth by Middleware', () => {
-    const crypto = global.crypto;
-    beforeAll(() => {
-        global.crypto = require('crypto').webcrypto;
-    });
-    afterAll(() => {
-        global.crypto = crypto;
-    });
-    const app = new hono_1.Hono();
-    app.use('/auth/*', (0, _1.jwt)({ secret: 'a-secret' }));
-    app.use('/auth-unicode/*', (0, _1.jwt)({ secret: 'a-secret' }));
-    app.get('/auth/*', () => new Response('auth'));
-    app.get('/auth-unicode/*', () => new Response('auth'));
-    it('Should not authorize', async () => {
-        const req = new Request('http://localhost/auth/a');
-        const res = await app.request(req);
-        expect(res).not.toBeNull();
-        expect(res.status).toBe(401);
-        expect(await res.text()).toBe('Unauthorized');
-    });
-    it('Should authorize', async () => {
-        const credential = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJtZXNzYWdlIjoiaGVsbG8gd29ybGQifQ.B54pAqIiLbu170tGQ1rY06Twv__0qSHTA0ioQPIOvFE';
-        const req = new Request('http://localhost/auth/a');
-        req.headers.set('Authorization', `Bearer ${credential}`);
-        const res = await app.request(req);
-        expect(res).not.toBeNull();
-        expect(res.status).toBe(200);
-        expect(await res.text()).toBe('auth');
-    });
-    it('Should authorize Unicode', async () => {
-        const credential = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJtZXNzYWdlIjoiaGVsbG8gd29ybGQifQ.B54pAqIiLbu170tGQ1rY06Twv__0qSHTA0ioQPIOvFE';
-        const req = new Request('http://localhost/auth-unicode/a');
-        req.headers.set('Authorization', `Basic ${credential}`);
-        const res = await app.request(req);
-        expect(res).not.toBeNull();
-        expect(res.status).toBe(200);
-        expect(await res.text()).toBe('auth');
-    });
-    it('Should authorize Unicode', async () => {
-        const invalidToken = 'ssyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJtZXNzYWdlIjoiaGVsbG8gd29ybGQifQ.B54pAqIiLbu170tGQ1rY06Twv__0qSHTA0ioQPIOvFE';
-        const req = new Request('http://localhost/auth-unicode/a');
-        req.headers.set('Authorization', `Basic ${invalidToken}`);
-        const res = await app.request(req);
-        expect(res).not.toBeNull();
-        expect(res.status).toBe(401);
-    });
-});

package/dist/middleware/logger/index.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/middleware/logger/index.test.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const hono_1 = require("../../hono");
-const _1 = require(".");
-describe('Logger by Middleware', () => {
-    const app = new hono_1.Hono();
-    let log = '';
-    const logFn = (str) => {
-        log = str;
-    };
-    const shortRandomString = 'hono';
-    const longRandomString = 'hono'.repeat(1000);
-    app.use('*', (0, _1.logger)(logFn));
-    app.get('/short', (c) => c.text(shortRandomString));
-    app.get('/long', (c) => c.text(longRandomString));
-    app.get('/empty', (c) => c.text(''));
-    it('Log status 200 with empty body', async () => {
-        const res = await app.request('http://localhost/empty');
-        expect(res).not.toBeNull();
-        expect(res.status).toBe(200);
-        expect(log.startsWith('  --> GET /empty \x1b[32m200\x1b[0m')).toBe(true);
-        expect(log).toMatch(/m?s$/);
-    });
-    it('Log status 200 with small body', async () => {
-        const res = await app.request('http://localhost/short');
-        expect(res).not.toBeNull();
-        expect(res.status).toBe(200);
-        expect(log.startsWith('  --> GET /short \x1b[32m200\x1b[0m')).toBe(true);
-        expect(log).toMatch(/m?s$/);
-    });
-    it('Log status 200 with big body', async () => {
-        const res = await app.request('http://localhost/long');
-        expect(res).not.toBeNull();
-        expect(res.status).toBe(200);
-        expect(log.startsWith('  --> GET /long \x1b[32m200\x1b[0m')).toBe(true);
-        expect(log).toMatch(/m?s$/);
-    });
-    it('Log status 404', async () => {
-        const msg = 'Default 404 Not Found';
-        app.all('*', (c) => {
-            return c.text(msg, 404);
-        });
-        const res = await app.request('http://localhost/notfound');
-        expect(res).not.toBeNull();
-        expect(res.status).toBe(404);
-        expect(log.startsWith('  --> GET /notfound \x1b[33m404\x1b[0m')).toBe(true);
-        expect(log).toMatch(/m?s$/);
-    });
-});

package/dist/middleware/mustache/index.test.d.ts

@@ -1 +0,0 @@
-export {};