12483800089

Committed 24 Dec 2024 03:57PM UTC coverage: 66.935% (+0.1%) from 66.83%

Build # 12483800089

Build Type

push

github

Committed by

yiminghe

Commit Message

error on cookie

Run Details

61 of 133 branches covered (45.86%)

Branch coverage included in aggregate %.

8 of 9 new or added lines in 3 files covered. (88.89%)

354 of 487 relevant lines covered (72.69%)

3.12 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

71.76

/source/next-context.ts

import type {
  NextContext,
  CookieAttributes,
  NextContextResponseInternal,
  ClientCookieAttributes,
} from './types';
import type { NextRequest } from 'next/server';
import { cookies as getCookies, headers as getHeaders } from 'next/headers';
import {
  NEXT_URL_HEADER,
  FORWARDED_URI_HEADER,
  FORWARDED_PROTO_HEADER,
  FORWARDED_HOST_HEADER,
  FORWARDED_FOR_HEADER,
  NEXT_BASE_PATH_HEADER,
  INIT_TOKEN,
} from './constants';
import { NextURL } from 'next/dist/server/web/next-url';

async function transformCookiesToObject(): Promise<any> {
  const originals = (await getCookies()).getAll();
  const cookies: any = {};
  for (const h of originals) {
    cookies[h.name] = h.value;
  }
  return cookies;
}

async function transformHeadersToObject(): Promise<any> {
  const originals = await getHeaders();
  const headers: any = {};
  for (const h of Array.from(originals.keys())) {
    headers[h] = originals.get(h);
  }
  return headers;
}

function buildResponse(): NextContextResponseInternal {
  const p: NextContextResponseInternal['_private'] = {
    status: 200,
    headers: {},
  };
  const res = {
    _private: p,
    async clearCookie(name: string, options?: CookieAttributes) {
      (await getCookies()).set(name, '', {
        ...options,
        maxAge: 0,
      });
    },
    async cookie(name: string, value: string, options?: CookieAttributes) {
      (await getCookies()).set(name, value, options);
    },
    append(k: string, v: string) {
      p.headers[k] = p.headers[k] ?? '';
      p.headers[k] += v;
    },
    set(...args: any) {
      const [k, v] = args;
      if (typeof k === 'string') {
        p.headers[k] = v;
        return;
      }
      Object.assign(p.headers, k);
    },
    get(k: string) {
      return p.headers[k];
    },
    status(s: number) {
      p.status = s;
    },
    json(j: any) {
      p.json = j;
    },
    redirect(r: string) {
      p.redirectUrl = r;
    },
  };
  return res;
}

async function buildRequest() {
  const headers = await transformHeadersToObject();
  function get(k: string) {
    return headers[k];
  }
  if (!headers[FORWARDED_URI_HEADER]) {
    throw new Error('must setup middleware!');
  }
  const stringUrl = `${headers[FORWARDED_PROTO_HEADER]}://${headers[FORWARDED_HOST_HEADER]}${headers[FORWARDED_URI_HEADER]}`;
  const url = new URL(stringUrl);
  const searchParams: Record<string, any> = {};
  for (const [k, v] of Array.from(url.searchParams.entries())) {
    searchParams[k] = v;
  }
  const protocol = url.protocol.slice(0, -1);
  const nextUrl = new NextURL(headers[NEXT_URL_HEADER]);
  nextUrl.basePath = headers[NEXT_BASE_PATH_HEADER];
  nextUrl.pathname = nextUrl.pathname.slice(nextUrl.basePath.length);
  return {
    params: {},
    method: 'GET',
    cookies: await transformCookiesToObject(),
    text: () =>
      new Promise<string>((r) => {
        r('');
      }),
    json: () =>
      new Promise<any>((r) => {
        r({});
      }),
    host: url.host,
    secure: protocol === 'https',
    url: url.toString(),
    nextUrl,
    path: url.pathname,
    query: searchParams,
    protocol,
    ip: headers[FORWARDED_FOR_HEADER],
    headers,
    get,
    header: get,
  };
}

export function buildPageResponse() {
  const res = buildResponse();
  function cookie(name: string, value: string, options_?: CookieAttributes) {
    const private_ = res._private;
    if (private_.cookieSent) {
      throw new Error('only can set cookie inside middleware and entry page!');
    }
    const { maxAge, expires, ...clientOptions_ } = options_ || {};
    let clientOptions: ClientCookieAttributes = clientOptions_;
    if (expires) {
      clientOptions.expires = +expires;
    } else if (typeof maxAge === 'number') {
      clientOptions.expires = Date.now() + maxAge * 1000;
    }
    private_.cookies = private_.cookies || {};
    private_.cookies[name] = { options: clientOptions, value };
  }
  return {
    ...res,
    cookie,
    clearCookie(name: string, options_?: CookieAttributes) {
      cookie(name, '', { ...options_, expires: new Date(0) });
    },
  };
}

export function createNextContextFromPage() {
  const context: NextContext = {
    type: 'page',
    req: null as any,
    res: buildPageResponse(),
  };
  (context as any)[INIT_TOKEN] = (async () => {
    context.req = await buildRequest();
    delete (context as any)[INIT_TOKEN];
  })();
  return context;
}

export async function createNextContextFromAction() {
  const res = buildResponse();
  const context: NextContext = {
    type: 'action',
    req: {
      ...(await buildRequest()),
      method: 'POST',
    },
    res,
  };
  return context;
}

export async function createNextContextFromRoute(req: NextRequest) {
  const context: NextContext = {
    type: 'route',
    res: buildResponse(),
    req: {
      ...(await buildRequest()),
      text: () => req.text(),
      json: () => req.json(),
      method: req.method,
    },
  };
  return context;
}

1	import type {
2	NextContext,
3	CookieAttributes,
4	NextContextResponseInternal,
5	ClientCookieAttributes,
6	} from './types';
7	import type { NextRequest } from 'next/server';
8	import { cookies as getCookies, headers as getHeaders } from 'next/headers';
9	import {
10	NEXT_URL_HEADER,
11	FORWARDED_URI_HEADER,
12	FORWARDED_PROTO_HEADER,
13	FORWARDED_HOST_HEADER,
14	FORWARDED_FOR_HEADER,
15	NEXT_BASE_PATH_HEADER,
16	INIT_TOKEN,
17	} from './constants';
18	import { NextURL } from 'next/dist/server/web/next-url';
19
20	async function transformCookiesToObject(): Promise<any> {
21	const originals = (await getCookies()).getAll();	5✔
22	const cookies: any = {};	5✔
23	for (const h of originals) {	5✔
24	cookies[h.name] = h.value;	6✔
25	}
26	return cookies;	5✔
27	}
28
29	async function transformHeadersToObject(): Promise<any> {
30	const originals = await getHeaders();	5✔
31	const headers: any = {};	5✔
32	for (const h of Array.from(originals.keys())) {	5✔
33	headers[h] = originals.get(h);	75✔
34	}
35	return headers;	5✔
36	}
37
38	function buildResponse(): NextContextResponseInternal {
39	const p: NextContextResponseInternal['_private'] = {	5✔
40	status: 200,
41	headers: {},
42	};
43	const res = {	5✔
44	_private: p,
45	async clearCookie(name: string, options?: CookieAttributes) {
46	(await getCookies()).set(name, '', {	×
47	...options,
48	maxAge: 0,
49	});
50	},
51	async cookie(name: string, value: string, options?: CookieAttributes) {
52	(await getCookies()).set(name, value, options);	6✔
53	},
54	append(k: string, v: string) {
55	p.headers[k] = p.headers[k] ?? '';	×
56	p.headers[k] += v;	×
57	},
58	set(...args: any) {
59	const [k, v] = args;	3✔
60	if (typeof k === 'string') {	3!
61	p.headers[k] = v;	3✔
62	return;	3✔
63	}
64	Object.assign(p.headers, k);	×
65	},
66	get(k: string) {
67	return p.headers[k];	×
68	},
69	status(s: number) {
70	p.status = s;	×
71	},
72	json(j: any) {
73	p.json = j;	3✔
74	},
75	redirect(r: string) {
76	p.redirectUrl = r;	×
77	},
78	};
79	return res;	5✔
80	}
81
82	async function buildRequest() {
83	const headers = await transformHeadersToObject();	5✔
84	function get(k: string) {
85	return headers[k];	×
86	}
87	if (!headers[FORWARDED_URI_HEADER]) {	5!
88	throw new Error('must setup middleware!');	×
89	}
90	const stringUrl = `${headers[FORWARDED_PROTO_HEADER]}://${headers[FORWARDED_HOST_HEADER]}${headers[FORWARDED_URI_HEADER]}`;	5✔
91	const url = new URL(stringUrl);	5✔
92	const searchParams: Record<string, any> = {};	5✔
93	for (const [k, v] of Array.from(url.searchParams.entries())) {	5✔
94	searchParams[k] = v;	×
95	}
96	const protocol = url.protocol.slice(0, -1);	5✔
97	const nextUrl = new NextURL(headers[NEXT_URL_HEADER]);	5✔
98	nextUrl.basePath = headers[NEXT_BASE_PATH_HEADER];	5✔
99	nextUrl.pathname = nextUrl.pathname.slice(nextUrl.basePath.length);	5✔
100	return {	5✔
101	params: {},
102	method: 'GET',
103	cookies: await transformCookiesToObject(),
104	text: () =>
105	new Promise<string>((r) => {	×
106	r('');	×
107	}),
108	json: () =>
109	new Promise<any>((r) => {	×
110	r({});	×
111	}),
112	host: url.host,
113	secure: protocol === 'https',
114	url: url.toString(),
115	nextUrl,
116	path: url.pathname,
117	query: searchParams,
118	protocol,
119	ip: headers[FORWARDED_FOR_HEADER],
120	headers,
121	get,
122	header: get,
123	};
124	}
125
126	export function buildPageResponse() {
127	const res = buildResponse();	1✔
128	function cookie(name: string, value: string, options_?: CookieAttributes) {
129	const private_ = res._private;	3✔
130	if (private_.cookieSent) {	3!
NEW 131	throw new Error('only can set cookie inside middleware and entry page!');	×
132	}
133	const { maxAge, expires, ...clientOptions_ } = options_ \|\| {};	3!
134	let clientOptions: ClientCookieAttributes = clientOptions_;	3✔
135	if (expires) {	3✔
136	clientOptions.expires = +expires;	1✔
137	} else if (typeof maxAge === 'number') {	2✔
138	clientOptions.expires = Date.now() + maxAge * 1000;	1✔
139	}
140	private_.cookies = private_.cookies \|\| {};	3✔
141	private_.cookies[name] = { options: clientOptions, value };	3✔
142	}
143	return {	1✔
144	...res,
145	cookie,
146	clearCookie(name: string, options_?: CookieAttributes) {
147	cookie(name, '', { ...options_, expires: new Date(0) });	×
148	},
149	};
150	}
151
152	export function createNextContextFromPage() {
153	const context: NextContext = {	1✔
154	type: 'page',
155	req: null as any,
156	res: buildPageResponse(),
157	};
158	(context as any)[INIT_TOKEN] = (async () => {	1✔
159	context.req = await buildRequest();	1✔
160	delete (context as any)[INIT_TOKEN];	1✔
161	})();
162	return context;	1✔
163	}
164
165	export async function createNextContextFromAction() {
166	const res = buildResponse();	1✔
167	const context: NextContext = {	1✔
168	type: 'action',
169	req: {
170	...(await buildRequest()),
171	method: 'POST',
172	},
173	res,
174	};
175	return context;	1✔
176	}
177
178	export async function createNextContextFromRoute(req: NextRequest) {
179	const context: NextContext = {
180	type: 'route',
181	res: buildResponse(),
182	req: {
183	...(await buildRequest()),
184	text: () => req.text(),	×
185	json: () => req.json(),	×
186	method: req.method,
187	},
188	};
189	return context;	3✔
190	}

yiminghe / next-compose-middlewares / 12483800089

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous