10892857262

Committed 16 Sep 2024 10:14PM UTC coverage: 13.754% (+0.05%) from 13.709%

Build # 10892857262

Build Type

Pull #9248

github

Committed by

web-flow

Commit Message

Merge 98b8f6143 into 81f186948

Pull Request Pull Request #9248: add output middleware to commit canvas signed data

Run Details

3049 of 20612 branches covered (14.79%)

Branch coverage included in aggregate %.

5 of 7 new or added lines in 5 files covered. (71.43%)

1 existing line in 1 file now uncovered.

3982 of 30508 relevant lines covered (13.05%)

3.96 hits per line

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

12.99

/libs/adapters/src/trpc/middleware.ts

import {
  analytics,
  logger,
  stats,
  type Actor,
  type AuthStrategies,
  type User,
} from '@hicommonwealth/core';
import { TRPCError, initTRPC } from '@trpc/server';
import { Request, Response } from 'express';
import passport from 'passport';
import { OpenApiMeta } from 'trpc-swagger';
import { ZodSchema, z } from 'zod';
import { config } from '../config';

const log = logger(import.meta);

type Metadata<Input extends ZodSchema, Output extends ZodSchema> = {
  readonly input: Input;
  readonly output: Output;
  auth: unknown[];
  secure?: boolean;
  authStrategy?: AuthStrategies;
};

const isSecure = (md: Metadata<ZodSchema, ZodSchema>) =>
  md.secure !== false || (md.auth ?? []).length > 0;

export interface Context {
  req: Request;
  res: Response;
  actor: Actor;
}

const trpc = initTRPC.meta<OpenApiMeta>().context<Context>().create();
export const router = trpc.router;
export const procedure = trpc.procedure;

export enum Tag {
  User = 'User',
  Community = 'Community',
  Thread = 'Thread',
  Comment = 'Comment',
  Reaction = 'Reaction',
  Integration = 'Integration',
  Subscription = 'Subscription',
  LoadTest = 'LoadTest',
  Wallet = 'Wallet',
  Webhook = 'Webhook',
  SuperAdmin = 'SuperAdmin',
}

export type Commit<Input extends ZodSchema, Output extends ZodSchema> = (
  input: z.infer<Input>,
  output: z.infer<Output>,
) => Promise<[string, Record<string, unknown>] | undefined>;

/**
 * Supports two options to track analytics
 * 1. A declarative tuple with [event name, optional output mapper]
 * 2. A "general" async mapper that derives the tuple of [event name, data] from input/output
 */
export type Track<Input extends ZodSchema, Output extends ZodSchema> =
  | [string, mapper?: (output: z.infer<Output>) => Record<string, unknown>]
  | ((
      input: z.infer<Input>,
      output: z.infer<Output>,
    ) => Promise<[string, Record<string, unknown>] | undefined>);

async function evalTrack<Input extends ZodSchema, Output extends ZodSchema>(
  track: Track<Input, Output>,
  input: z.infer<Input>,
  output: z.infer<Output>,
) {
  if (typeof track === 'function') {
    const tuple = await track(input, output);
    return tuple
      ? { event: tuple[0], data: tuple[1] }
      : { event: undefined, data: undefined };
  }
  return {
    event: track[0],
    data: track[1] ? track[1](output) : {},
  };
}

/**
 * Returns a record containing condensed browser info.
 * Expects the 'express-useragent' middleware to be applied to the route.
 * Includes 'is...' boolean entries if the value is true, and all string values
 */
function getRequestBrowserInfo(
  req: Request & { useragent?: Record<string, unknown> },
) {
  const info: Record<string, unknown> = req.useragent
    ? Object.entries(req.useragent)
        .filter(([k, v]) => typeof v === 'string' || (k.startsWith('is') && v))
        .reduce((p, [k, v]) => Object.assign(p, { [k]: v }), {})
    : {};
  const brand = req.headers['sec-ch-ua'];
  if (typeof brand === 'string' && brand.includes('Brave')) {
    delete info['isChrome'];
    info['isBrave'] = true;
    info['browser'] = 'Brave';
  }
  return info;
}

async function trackAnalytics<
  Input extends ZodSchema,
  Output extends ZodSchema,
>(
  track: Track<Input, Output>,
  ctx: Context,
  input: z.infer<Input>,
  output: z.infer<Output>,
) {
  try {
    const host = ctx.req.headers.host;
    const { event, data } = await evalTrack(track, input, output);
    if (event) {
      const payload = {
        ...data,
        ...getRequestBrowserInfo(ctx.req),
        ...(host && { isCustomDomain: config.SERVER_URL.includes(host) }),
        userId: ctx.actor.user.id,
        isPWA: ctx.req.headers?.['isPWA'] === 'true',
      };
      analytics().track(event, payload);
    }
  } catch (err) {
    err instanceof Error && log.error(err.message, err);
  }
}

/**
 * tRPC procedure factory with authentication, traffic stats, and analytics middleware
 */
export const buildproc = <Input extends ZodSchema, Output extends ZodSchema>(
  method: 'GET' | 'POST',
  name: string,
  md: Metadata<Input, Output>,
  tag: Tag,
  track?: Track<Input, Output>,
  commit?: Commit<Input, Output>,
) => {
  const secure = isSecure(md);
  return trpc.procedure
    .use(async ({ ctx, next }) => {
      if (secure) await authenticate(ctx.req, md.authStrategy);
      return next({
        ctx: {
          ...ctx,
          actor: {
            user: ctx.req.user as User,
            address: ctx.req.headers['address'] as string,
          },
        },
      });
    })
    .use(async ({ ctx, rawInput, next }) => {
      const start = Date.now();
      const result = await next();
      const latency = Date.now() - start;
      try {
        const path = `${ctx.req.method.toUpperCase()} ${ctx.req.path}`;
        stats().increment('cw.path.called', { path });
        stats().histogram(`cw.path.latency`, latency, {
          path,
          statusCode: ctx.res.statusCode.toString(),
        });
      } catch (err) {
        err instanceof Error && log.error(err.message, err);
      }
      track &&
        result.ok &&
        void trackAnalytics(track, ctx, rawInput, result.data);
      commit && result.ok && void commit(rawInput, result.data);
      return result;
    })
    .meta({
      openapi: {
        method,
        path: `/${name}`,
        tags: [tag],
        headers: [
          {
            in: 'header',
            name: 'address',
            required: false,
            schema: { type: 'string' },
          },
        ],
        protect: secure,
      },
    })
    .input(md.input)
    .output(md.output);
};

const authenticate = async (
  req: Request,
  authStrategy: AuthStrategies = { name: 'jwt' },
) => {
  try {
    if (authStrategy.name === 'authtoken') {
      switch (req.headers['authorization']) {
        case config.NOTIFICATIONS.KNOCK_AUTH_TOKEN:
          req.user = {
            id: authStrategy.userId,
            email: 'hello@knock.app',
          };
          break;
        case config.LOAD_TESTING.AUTH_TOKEN:
          req.user = {
            id: authStrategy.userId,
            email: 'info@grafana.com',
          };
          break;
        default:
          throw new Error('Not authenticated');
      }
    } else if (authStrategy.name === 'custom') {
      authStrategy.customStrategyFn(req);
      req.user = {
        id: authStrategy.userId,
      };
    } else {
      await passport.authenticate(authStrategy.name, { session: false });
    }

    if (!req.user) throw new Error('Not authenticated');
    if (authStrategy.userId && (req.user as User).id !== authStrategy.userId) {
      throw new Error('Not authenticated');
    }
  } catch (error) {
    throw new TRPCError({
      message: error instanceof Error ? error.message : (error as string),
      code: 'UNAUTHORIZED',
    });
  }
};

1	import {
2	analytics,
3	logger,
4	stats,
5	type Actor,
6	type AuthStrategies,
7	type User,
8	} from '@hicommonwealth/core';
9	import { TRPCError, initTRPC } from '@trpc/server';
10	import { Request, Response } from 'express';
11	import passport from 'passport';
12	import { OpenApiMeta } from 'trpc-swagger';
13	import { ZodSchema, z } from 'zod';
14	import { config } from '../config';
15
16	const log = logger(import.meta);	4✔
17
18	type Metadata<Input extends ZodSchema, Output extends ZodSchema> = {
19	readonly input: Input;
20	readonly output: Output;
21	auth: unknown[];
22	secure?: boolean;
23	authStrategy?: AuthStrategies;
24	};
25
26	const isSecure = (md: Metadata<ZodSchema, ZodSchema>) =>	4✔
27	md.secure !== false \|\| (md.auth ?? []).length > 0;	×
28
29	export interface Context {
30	req: Request;
31	res: Response;
32	actor: Actor;
33	}
34
35	const trpc = initTRPC.meta<OpenApiMeta>().context<Context>().create();	4✔
36	export const router = trpc.router;	4✔
37	export const procedure = trpc.procedure;	4✔
38
39	export enum Tag {	4✔
40	User = 'User',	4✔
41	Community = 'Community',	4✔
42	Thread = 'Thread',	4✔
43	Comment = 'Comment',	4✔
44	Reaction = 'Reaction',	4✔
45	Integration = 'Integration',	4✔
46	Subscription = 'Subscription',	4✔
47	LoadTest = 'LoadTest',	4✔
48	Wallet = 'Wallet',	4✔
49	Webhook = 'Webhook',	4✔
50	SuperAdmin = 'SuperAdmin',	4✔
51	}
52
53	export type Commit<Input extends ZodSchema, Output extends ZodSchema> = (
54	input: z.infer<Input>,
55	output: z.infer<Output>,
56	) => Promise<[string, Record<string, unknown>] \| undefined>;
57
58	/**
59	* Supports two options to track analytics
60	* 1. A declarative tuple with [event name, optional output mapper]
61	* 2. A "general" async mapper that derives the tuple of [event name, data] from input/output
62	*/
63	export type Track<Input extends ZodSchema, Output extends ZodSchema> =
64	\| [string, mapper?: (output: z.infer<Output>) => Record<string, unknown>]
65	\| ((
66	input: z.infer<Input>,
67	output: z.infer<Output>,
68	) => Promise<[string, Record<string, unknown>] \| undefined>);
69
70	async function evalTrack<Input extends ZodSchema, Output extends ZodSchema>(
71	track: Track<Input, Output>,
72	input: z.infer<Input>,
73	output: z.infer<Output>,
74	) {
75	if (typeof track === 'function') {	×
76	const tuple = await track(input, output);	×
77	return tuple	×
78	? { event: tuple[0], data: tuple[1] }
79	: { event: undefined, data: undefined };
80	}
81	return {	×
82	event: track[0],
83	data: track[1] ? track[1](output) : {},	×
84	};
85	}
86
87	/**
88	* Returns a record containing condensed browser info.
89	* Expects the 'express-useragent' middleware to be applied to the route.
90	* Includes 'is...' boolean entries if the value is true, and all string values
91	*/
92	function getRequestBrowserInfo(
93	req: Request & { useragent?: Record<string, unknown> },
94	) {
95	const info: Record<string, unknown> = req.useragent	×
96	? Object.entries(req.useragent)
97	.filter(([k, v]) => typeof v === 'string' \|\| (k.startsWith('is') && v))	×
98	.reduce((p, [k, v]) => Object.assign(p, { [k]: v }), {})	×
99	: {};
100	const brand = req.headers['sec-ch-ua'];	×
101	if (typeof brand === 'string' && brand.includes('Brave')) {	×
102	delete info['isChrome'];	×
103	info['isBrave'] = true;	×
104	info['browser'] = 'Brave';	×
105	}
106	return info;	×
107	}
108
109	async function trackAnalytics<
110	Input extends ZodSchema,
111	Output extends ZodSchema,
112	>(
113	track: Track<Input, Output>,
114	ctx: Context,
115	input: z.infer<Input>,
116	output: z.infer<Output>,
117	) {
118	try {	×
119	const host = ctx.req.headers.host;	×
120	const { event, data } = await evalTrack(track, input, output);	×
121	if (event) {	×
122	const payload = {	×
123	...data,
124	...getRequestBrowserInfo(ctx.req),
125	...(host && { isCustomDomain: config.SERVER_URL.includes(host) }),	×
126	userId: ctx.actor.user.id,
127	isPWA: ctx.req.headers?.['isPWA'] === 'true',
128	};
129	analytics().track(event, payload);	×
130	}
131	} catch (err) {
132	err instanceof Error && log.error(err.message, err);	×
133	}
134	}
135
136	/**
137	* tRPC procedure factory with authentication, traffic stats, and analytics middleware
138	*/
139	export const buildproc = <Input extends ZodSchema, Output extends ZodSchema>(	4✔
140	method: 'GET' \| 'POST',
141	name: string,
142	md: Metadata<Input, Output>,
143	tag: Tag,
144	track?: Track<Input, Output>,
145	commit?: Commit<Input, Output>,
146	) => {
147	const secure = isSecure(md);	×
148	return trpc.procedure	×
149	.use(async ({ ctx, next }) => {
150	if (secure) await authenticate(ctx.req, md.authStrategy);	×
151	return next({	×
152	ctx: {
153	...ctx,
154	actor: {
155	user: ctx.req.user as User,
156	address: ctx.req.headers['address'] as string,
157	},
158	},
159	});
160	})
161	.use(async ({ ctx, rawInput, next }) => {
162	const start = Date.now();	×
163	const result = await next();	×
164	const latency = Date.now() - start;	×
165	try {	×
166	const path = `${ctx.req.method.toUpperCase()} ${ctx.req.path}`;	×
167	stats().increment('cw.path.called', { path });	×
168	stats().histogram(`cw.path.latency`, latency, {	×
169	path,
170	statusCode: ctx.res.statusCode.toString(),
171	});
172	} catch (err) {
173	err instanceof Error && log.error(err.message, err);	×
174	}
175	track &&	×
176	result.ok &&
177	void trackAnalytics(track, ctx, rawInput, result.data);
NEW 178	commit && result.ok && void commit(rawInput, result.data);	×
UNCOV 179	return result;	×
180	})
181	.meta({
182	openapi: {
183	method,
184	path: `/${name}`,
185	tags: [tag],
186	headers: [
187	{
188	in: 'header',
189	name: 'address',
190	required: false,
191	schema: { type: 'string' },
192	},
193	],
194	protect: secure,
195	},
196	})
197	.input(md.input)
198	.output(md.output);
199	};
200
201	const authenticate = async (	4✔
202	req: Request,
203	authStrategy: AuthStrategies = { name: 'jwt' },	×
204	) => {
205	try {	×
206	if (authStrategy.name === 'authtoken') {	×
207	switch (req.headers['authorization']) {	×
208	case config.NOTIFICATIONS.KNOCK_AUTH_TOKEN:
209	req.user = {	×
210	id: authStrategy.userId,
211	email: 'hello@knock.app',
212	};
213	break;	×
214	case config.LOAD_TESTING.AUTH_TOKEN:
215	req.user = {	×
216	id: authStrategy.userId,
217	email: 'info@grafana.com',
218	};
219	break;	×
220	default:
221	throw new Error('Not authenticated');	×
222	}
223	} else if (authStrategy.name === 'custom') {	×
224	authStrategy.customStrategyFn(req);	×
225	req.user = {	×
226	id: authStrategy.userId,
227	};
228	} else {
229	await passport.authenticate(authStrategy.name, { session: false });	×
230	}
231
232	if (!req.user) throw new Error('Not authenticated');	×
233	if (authStrategy.userId && (req.user as User).id !== authStrategy.userId) {	×
234	throw new Error('Not authenticated');	×
235	}
236	} catch (error) {
237	throw new TRPCError({	×
238	message: error instanceof Error ? error.message : (error as string),	×
239	code: 'UNAUTHORIZED',
240	});
241	}
242	};

hicommonwealth / commonwealth / 10892857262

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