beenull/runtipi
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

chore: cleanup trpc related code

Browse source
This commit is contained in:
Nicolas Meienberger 2023-10-06 08:55:31 +02:00 committed by Nicolas Meienberger
parent 34006c680b
commit 36675a67d4
24 changed files with 20 additions and 844 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
src/app/(dashboard)/app-store/[id]/components/AppActions/AppActions.tsx
View file

@ -5,11 +5,11 @@ import type { AppStatus } from '@/server/db/schema';
import { useTranslations } from 'next-intl';
import { DropdownMenu, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuTrigger } from '@/components/ui/DropdownMenu';
import { AppWithInfo } from '@/client/core/types';
import { Button } from '@/components/ui/Button';
import type { AppService } from '@/server/services/apps/apps.service';
interface IProps {
app: AppWithInfo;
app: Awaited<ReturnType<AppService['getApp']>>;
status?: AppStatus;
updateAvailable: boolean;
localDomain?: string;

4
src/app/(dashboard)/app-store/[id]/components/AppDetailsContainer/AppDetailsContainer.tsx
View file

@ -3,7 +3,6 @@
import React from 'react';
import { toast } from 'react-hot-toast';
import { useTranslations } from 'next-intl';
import { AppRouterOutput } from '@/server/routers/app/app.router';
import { useDisclosure } from '@/client/hooks/useDisclosure';
import { useAction } from 'next-safe-action/hook';
import { installAppAction } from '@/actions/app-actions/install-app-action';
@ -16,6 +15,7 @@ import { AppLogo } from '@/components/AppLogo';
import { AppStatus } from '@/components/AppStatus';
import { AppStatus as AppStatusEnum } from '@/server/db/schema';
import { castAppConfig } from '@/lib/helpers/castAppConfig';
import { AppService } from '@/server/services/apps/apps.service';
import { InstallModal } from '../InstallModal';
import { StopModal } from '../StopModal';
import { UninstallModal } from '../UninstallModal';
@ -26,7 +26,7 @@ import { AppDetailsTabs } from '../AppDetailsTabs';
import { FormValues } from '../InstallForm';
interface IProps {
app: AppRouterOutput['getApp'];
app: Awaited<ReturnType<AppService['getApp']>>;
localDomain?: string;
}
type OpenType = 'local' | 'domain' | 'local_domain';

3
src/app/(dashboard)/apps/page.tsx
View file

@ -1,7 +1,6 @@
import { AppServiceClass } from '@/server/services/apps/apps.service';
import { db } from '@/server/db';
import React from 'react';
import { AppRouterOutput } from '@/server/routers/app/app.router';
import { Metadata } from 'next';
import { getTranslatorFromCookie } from '@/lib/get-translator';
import { AppTile } from './components/AppTile';
@ -19,7 +18,7 @@ export default async function Page() {
const appsService = new AppServiceClass(db);
const installedApps = await appsService.installedApps();
const renderApp = (app: AppRouterOutput['installedApps'][number]) => {
const renderApp = (app: (typeof installedApps)[number]) => {
const updateAvailable = Number(app.version) < Number(app.latestVersion);
if (app.info?.available) return <AppTile key={app.id} app={app.info} status={app.status} updateAvailable={updateAvailable} />;

4
src/client/core/types.ts
View file

@ -1,4 +0,0 @@
import * as Router from '../../server/routers/_app';
export type App = Omit<Router.RouterOutput['app']['getApp'], 'info'>;
export type AppWithInfo = Router.RouterOutput['app']['getApp'];

109
src/client/hooks/__tests__/useLocale.test.ts
View file

@ -1,109 +0,0 @@
import { getTRPCMock } from '@/client/mocks/getTrpcMock';
import { server } from '@/client/mocks/server';
import { deleteCookie, setCookie, getCookie } from 'cookies-next';
import { renderHook, waitFor } from '../../../../tests/test-utils';
import { useLocale } from '../useLocale';
beforeEach(() => {
deleteCookie('tipi-locale');
});
describe('test: useLocale()', () => {
describe('test: locale', () => {
it('should return users locale if logged in', async () => {
// arrange
const locale = 'fr-FR';
// @ts-expect-error - we're mocking the trpc context
server.use(getTRPCMock({ path: ['auth', 'me'], response: { locale } }));
// act
const { result } = renderHook(() => useLocale());
// assert
await waitFor(() => {
expect(result.current.locale).toEqual(locale);
});
});
it('should return cookie locale if not logged in', async () => {
// arrange
const locale = 'fr-FR';
setCookie('tipi-locale', locale);
server.use(getTRPCMock({ path: ['auth', 'me'], response: null }));
// act
const { result } = renderHook(() => useLocale());
// assert
await waitFor(() => {
expect(result.current.locale).toEqual(locale);
});
});
it('should return browser locale if not logged in and no cookie', async () => {
// arrange
const locale = 'fr-FR';
jest.spyOn(window.navigator, 'language', 'get').mockReturnValueOnce(locale);
server.use(getTRPCMock({ path: ['auth', 'me'], response: null }));
// act
const { result } = renderHook(() => useLocale());
// assert
await waitFor(() => {
expect(result.current.locale).toEqual(locale);
});
});
it('should default to english if no locale is found', async () => {
// arrange
server.use(getTRPCMock({ path: ['auth', 'me'], response: null }));
// @ts-expect-error - we're mocking window.navigator
jest.spyOn(window.navigator, 'language', 'get').mockReturnValueOnce(undefined);
// act
const { result } = renderHook(() => useLocale());
// assert
await waitFor(() => {
expect(result.current.locale).toEqual('en-US');
});
});
});
describe('test: changeLocale()', () => {
it('should set the locale in the cookie', async () => {
// arrange
const locale = 'fr-FR';
const { result } = renderHook(() => useLocale());
// act
result.current.changeLocale(locale);
// assert
await waitFor(() => {
expect(getCookie('tipi-locale')).toEqual('fr-FR');
});
});
it('should update the locale in the user profile when logged in', async () => {
// arrange
const locale = 'en';
// @ts-expect-error - we're mocking the trpc context
server.use(getTRPCMock({ path: ['auth', 'me'], response: { locale: 'fr-FR' } }));
server.use(getTRPCMock({ path: ['auth', 'changeLocale'], type: 'mutation', response: true }));
const { result } = renderHook(() => useLocale());
await waitFor(() => {
expect(result.current.locale).toEqual('fr-FR');
});
// act
result.current.changeLocale(locale);
// assert
await waitFor(() => {
expect(getCookie('tipi-locale')).toEqual(locale);
});
});
});
});

30
src/client/hooks/useLocale.ts
View file

@ -1,30 +0,0 @@
import { setCookie, getCookie } from 'cookies-next';
import { useRouter } from 'next/router';
import { trpc } from '@/utils/trpc';
import { Locale, getLocaleFromString } from '@/shared/internationalization/locales';
export const useLocale = () => {
const router = useRouter();
const me = trpc.auth.me.useQuery();
const changeUserLocale = trpc.auth.changeLocale.useMutation();
const browserLocale = typeof window !== 'undefined' ? window.navigator.language : undefined;
const cookieLocale = getCookie('tipi-locale');
const locale = String(me.data?.locale || cookieLocale || browserLocale || 'en');
const ctx = trpc.useContext();
const changeLocale = async (l: Locale) => {
if (me.data) {
await changeUserLocale.mutateAsync({ locale: l });
await ctx.invalidate();
}
setCookie('tipi-locale', l, {
expires: new Date(Date.now() + 1000 * 60 * 60 * 24 * 365),
});
router.reload();
};
return { locale: getLocaleFromString(locale), changeLocale };
};

64
src/client/mocks/fixtures/app.fixtures.ts
View file

@ -1,64 +0,0 @@
import { faker } from '@faker-js/faker';
import type { AppStatus } from '@/server/db/schema';
import { AppInfo, AppCategory, APP_CATEGORIES } from '@runtipi/shared';
import { App, AppWithInfo } from '../../core/types';
const randomCategory = (): AppCategory[] => {
const categories = Object.values(APP_CATEGORIES);
const randomIndex = faker.number.int({ min: 0, max: categories.length - 1 });
return [categories[randomIndex] as AppCategory];
};
const createApp = (overrides?: Partial<AppInfo>): AppInfo => {
const name = faker.lorem.word();
return {
id: name.toLowerCase(),
name,
description: faker.lorem.words(),
author: faker.lorem.word(),
available: true,
categories: randomCategory(),
form_fields: [],
port: faker.number.int({ min: 1000, max: 9999 }),
short_desc: faker.lorem.words(),
tipi_version: 1,
version: faker.system.semver(),
source: faker.internet.url(),
https: false,
no_gui: false,
exposable: true,
url_suffix: '',
force_expose: false,
generate_vapid_keys: false,
...overrides,
};
};
type CreateAppEntityParams = {
overrides?: Omit<Partial<App>, 'info'>;
overridesInfo?: Partial<AppInfo>;
status?: AppStatus;
};
export const createAppEntity = (params: CreateAppEntityParams): AppWithInfo => {
const { overrides, overridesInfo, status = 'running' } = params;
const id = faker.lorem.word().toLowerCase();
const app = createApp({ id, ...overridesInfo });
return {
id,
status,
info: app,
config: {},
exposed: false,
domain: null,
version: 1,
lastOpened: faker.date.past().toISOString(),
numOpened: 0,
createdAt: faker.date.past().toISOString(),
updatedAt: faker.date.past().toISOString(),
latestVersion: 1,
latestDockerVersion: '1.0.0',
...overrides,
};
};

91
src/client/mocks/getTrpcMock.ts
View file

@ -1,91 +0,0 @@
import { rest } from 'msw';
import SuperJSON from 'superjson';
import type { RouterInput, RouterOutput } from '../../server/routers/_app';
type RpcSuccessResponse<Data> = {
id: null;
result: { type: 'data'; data: Data };
};
type RpcErrorResponse = {
error: {
json: {
message: string;
code: number;
data: {
code: string;
httpStatus: number;
stack: string;
path: string; // TQuery
zodError?: Record<string, string>;
tError: {
message: string;
};
};
};
};
};
const jsonRpcSuccessResponse = (data: unknown): RpcSuccessResponse<unknown> => {
const response = SuperJSON.serialize(data);
return {
id: null,
result: { type: 'data', data: response },
};
};
const jsonRpcErrorResponse = (path: string, status: number, message: string, zodError?: Record<string, string>): RpcErrorResponse => ({
error: {
json: {
message,
code: -32600,
data: {
code: 'INTERNAL_SERVER_ERROR',
httpStatus: status,
stack: 'Error: Internal Server Error',
path,
zodError,
tError: {
message,
},
},
},
},
});
export const getTRPCMock = <
K1 extends keyof RouterInput,
K2 extends keyof RouterInput[K1], // object itself
O extends RouterOutput[K1][K2], // all its keys
>(endpoint: {
path: [K1, K2];
response: O;
type?: 'query' | 'mutation';
delay?: number;
}) => {
const fn = endpoint.type === 'mutation' ? rest.post : rest.get;
const route = `http://localhost:3000/api/trpc/${endpoint.path[0]}.${endpoint.path[1] as string}`;
return fn(route, (_, res, ctx) => res(ctx.delay(endpoint.delay), ctx.json(jsonRpcSuccessResponse(endpoint.response))));
};
export const getTRPCMockError = <
K1 extends keyof RouterInput,
K2 extends keyof RouterInput[K1], // object itself
>(endpoint: {
path: [K1, K2];
type?: 'query' | 'mutation';
status?: number;
message?: string;
zodError?: Record<string, string>;
}) => {
const fn = endpoint.type === 'mutation' ? rest.post : rest.get;
const route = `http://localhost:3000/api/trpc/${endpoint.path[0]}.${endpoint.path[1] as string}`;
return fn(route, (_, res, ctx) =>
res(ctx.delay(), ctx.json(jsonRpcErrorResponse(`${endpoint.path[0]}.${endpoint.path[1] as string}`, endpoint.status ?? 500, endpoint.message ?? 'Internal Server Error', endpoint.zodError))),
);
};

57
src/client/mocks/handlers.ts
View file

@ -1,56 +1 @@
import { faker } from '@faker-js/faker';
import { createAppEntity } from './fixtures/app.fixtures';
import { getTRPCMock } from './getTrpcMock';
import { createAppConfig } from '../../server/tests/apps.factory';
export const handlers = [
getTRPCMock({
path: ['system', 'getVersion'],
type: 'query',
response: { current: '1.0.0', latest: '1.0.0', body: 'hello' },
}),
getTRPCMock({
path: ['system', 'restart'],
type: 'mutation',
response: true,
delay: 100,
}),
getTRPCMock({
path: ['system', 'getSettings'],
type: 'query',
response: { internalIp: 'localhost', dnsIp: '1.1.1.1', appsRepoUrl: 'https://test.com/test', domain: 'tipi.localhost', localDomain: 'tipi.lan' },
}),
getTRPCMock({
path: ['system', 'updateSettings'],
type: 'mutation',
response: undefined,
}),
// Auth
getTRPCMock({
path: ['auth', 'me'],
type: 'query',
response: {
totpEnabled: false,
id: faker.number.int(),
username: faker.internet.userName(),
locale: 'en',
operator: true,
},
}),
// App
getTRPCMock({
path: ['app', 'getApp'],
type: 'query',
response: createAppEntity({ status: 'running' }),
}),
getTRPCMock({
path: ['app', 'installedApps'],
type: 'query',
response: [createAppEntity({ status: 'running' }), createAppEntity({ status: 'stopped' })],
}),
getTRPCMock({
path: ['app', 'listApps'],
type: 'query',
response: { apps: [createAppConfig({}), createAppConfig({})], total: 2 },
}),
];
export const handlers = [];

96
src/client/utils/__tests__/page-helpers.test.ts
View file

@ -1,96 +0,0 @@
import merge from 'lodash.merge';
import { deleteCookie, setCookie } from 'cookies-next';
import { fromPartial } from '@total-typescript/shoehorn';
import { TipiCache } from '@/server/core/TipiCache';
import { getAuthedPageProps, getMessagesPageProps } from '../page-helpers';
import englishMessages from '../../messages/en.json';
import frenchMessages from '../../messages/fr-FR.json';
const cache = new TipiCache('page-helpers.test.ts');
afterAll(async () => {
await cache.close();
});
describe('test: getAuthedPageProps()', () => {
it('should redirect to /login if there is no user id in session', async () => {
// arrange
const ctx = { req: { headers: {} } };
// act
// @ts-expect-error - we're passing in a partial context
const { redirect } = await getAuthedPageProps(ctx);
// assert
expect(redirect.destination).toBe('/login');
expect(redirect.permanent).toBe(false);
});
it('should return props if there is a user id in session', async () => {
// arrange
const ctx = { req: { headers: { 'x-session-id': '123' } } };
await cache.set('session:123', '456');
// act
// @ts-expect-error - we're passing in a partial context
const { props } = await getAuthedPageProps(ctx);
// assert
expect(props).toEqual({});
});
});
describe('test: getMessagesPageProps()', () => {
beforeEach(() => {
deleteCookie('tipi-locale');
});
it('should return correct messages if the locale is in the session', async () => {
// arrange
const ctx = { req: { session: { locale: 'fr' }, headers: {} } };
// act
// @ts-expect-error - we're passing in a partial context
const { props } = await getMessagesPageProps(ctx);
// assert
expect(props.messages).toEqual(merge(frenchMessages, englishMessages));
});
it('should return correct messages if the locale in the cookie', async () => {
// arrange
const ctx = { req: { session: {}, headers: {} } };
setCookie('tipi-locale', 'fr-FR', { req: fromPartial(ctx.req) });
// act
// @ts-expect-error - we're passing in a partial context
const { props } = await getMessagesPageProps(ctx);
// assert
expect(props.messages).toEqual(merge(frenchMessages, englishMessages));
});
it('should return correct messages if the locale is detected from the browser', async () => {
// arrange
const ctx = { req: { session: {}, headers: { 'accept-language': 'fr-FR' } } };
// act
// @ts-expect-error - we're passing in a partial context
const { props } = await getMessagesPageProps(ctx);
// assert
expect(props.messages).toEqual(merge(frenchMessages, englishMessages));
});
it('should default to english messages if the locale is not found', async () => {
// arrange
const ctx = { req: { session: {}, headers: {} } };
// act
// @ts-expect-error - we're passing in a partial context
const { props } = await getMessagesPageProps(ctx);
// assert
expect(props.messages).toEqual(englishMessages);
});
});

42
src/client/utils/page-helpers.ts
View file

@ -1,42 +0,0 @@
import { GetServerSideProps } from 'next';
import merge from 'lodash.merge';
import { getLocaleFromString } from '@/shared/internationalization/locales';
import { getCookie } from 'cookies-next';
import { TipiCache } from '@/server/core/TipiCache';
export const getAuthedPageProps: GetServerSideProps = async (ctx) => {
const cache = new TipiCache('getAuthedPageProps');
const sessionId = ctx.req.headers['x-session-id'];
const userId = await cache.get(`session:${sessionId}`);
await cache.close();
if (!userId) {
return {
redirect: {
destination: '/login',
permanent: false,
},
};
}
return {
props: {},
};
};
export const getMessagesPageProps: GetServerSideProps = async (ctx) => {
const cookieLocale = getCookie('tipi-locale', { req: ctx.req });
const browserLocale = ctx.req.headers['accept-language']?.split(',')[0];
const locale = getLocaleFromString(String(cookieLocale || browserLocale || 'en'));
const englishMessages = (await import(`../messages/en.json`)).default;
const messages = (await import(`../messages/${locale}.json`)).default;
const mergedMessages = merge(englishMessages, messages);
return {
props: {
messages: mergedMessages,
},
};
};

41
src/client/utils/trpc.ts
View file

@ -1,41 +0,0 @@
import { httpBatchLink, loggerLink } from '@trpc/client';
import { createTRPCNext } from '@trpc/next';
import superjson from 'superjson';
import type { AppRouter } from '../../server/routers/_app';
/**
* Get base url for the current environment
*
* @returns {string} base url
*/
function getBaseUrl() {
if (typeof window !== 'undefined') {
// browser should use relative path
return '';
}
return `http://localhost:${process.env.PORT ?? 3000}`;
}
export const trpc = createTRPCNext<AppRouter>({
config() {
return {
transformer: superjson,
links: [
loggerLink({
enabled: (opts) => process.env.NODE_ENV === 'development' || (opts.direction === 'down' && opts.result instanceof Error),
}),
httpBatchLink({
url: `${getBaseUrl()}/api/trpc`,
fetch(url, options) {
return fetch(url, {
...options,
credentials: 'include',
});
},
}),
],
};
},
ssr: false,
});

45
src/pages/_app.tsx
View file

@ -1,17 +1,12 @@
import React, { useEffect } from 'react';
import { ReactQueryDevtools } from '@tanstack/react-query-devtools';
import type { AppProps } from 'next/app';
import Head from 'next/head';
import { NextIntlProvider, createTranslator } from 'next-intl';
import '../client/styles/global.css';
import '../client/styles/global.scss';
import 'react-tooltip/dist/react-tooltip.css';
import { Toaster } from 'react-hot-toast';
import { useLocale } from '@/client/hooks/useLocale';
import { useUIStore } from '../client/state/uiStore';
import { StatusProvider } from '../client/components/hoc/StatusProvider';
import { trpc } from '../client/utils/trpc';
import { SystemStatus, useSystemStore } from '../client/state/systemStore';
/**
* Next.js App component
@ -20,18 +15,7 @@ import { SystemStatus, useSystemStore } from '../client/state/systemStore';
* @returns {JSX.Element} - JSX element
*/
function MyApp({ Component, pageProps }: AppProps) {
const { setDarkMode, setTranslator } = useUIStore();
const { setStatus, setVersion, pollStatus } = useSystemStore();
const { locale } = useLocale();
trpc.system.status.useQuery(undefined, { networkMode: 'online', refetchInterval: 2000, onSuccess: (d) => setStatus((d.status as SystemStatus) || 'RUNNING'), enabled: pollStatus });
const version = trpc.system.getVersion.useQuery(undefined, { networkMode: 'online' });
useEffect(() => {
if (version.data) {
setVersion(version.data);
}
}, [setVersion, version.data]);
const { setDarkMode } = useUIStore();
// check theme on component mount
useEffect(() => {
@ -47,28 +31,17 @@ function MyApp({ Component, pageProps }: AppProps) {
themeCheck();
}, [setDarkMode]);
useEffect(() => {
const translator = createTranslator({
messages: pageProps.messages,
locale,
});
setTranslator(translator);
}, [pageProps.messages, locale, setTranslator]);
return (
<main className="h-100">
<NextIntlProvider locale={locale} messages={pageProps.messages}>
<Head>
<title>Tipi</title>
</Head>
<StatusProvider>
<Component {...pageProps} />
</StatusProvider>
<Toaster />
</NextIntlProvider>
<ReactQueryDevtools />
<Head>
<title>Tipi</title>
</Head>
<StatusProvider>
<Component {...pageProps} />
</StatusProvider>
<Toaster />
</main>
);
}
export default trpc.withTRPC(MyApp);
export default MyApp;

9
src/pages/api/trpc/[trpc].ts
View file

@ -1,9 +0,0 @@
import * as trpcNext from '@trpc/server/adapters/next';
import { createContext } from '../../../server/context';
import { mainRouter } from '../../../server/routers/_app';
// export API handler
export default trpcNext.createNextApiHandler({
router: mainRouter,
createContext,
});

46
src/server/context.ts
View file

@ -1,46 +0,0 @@
import { inferAsyncReturnType } from '@trpc/server';
import { CreateNextContextOptions } from '@trpc/server/adapters/next';
import { TipiCache } from './core/TipiCache/TipiCache';
type CreateContextOptions = {
req: CreateNextContextOptions['req'];
res: CreateNextContextOptions['res'];
sessionId: string;
userId?: number;
};
/**
* Use this helper for:
* - testing, so we dont have to mock Next.js' req/res
* - trpc's `createSSGHelpers` where we don't have req/res
*
* @param {CreateContextOptions} opts - options
* @see https://create.t3.gg/en/usage/trpc#-servertrpccontextts
*/
const createContextInner = async (opts: CreateContextOptions) => ({
...opts,
});
/**
* This is the actual context you'll use in your router
*
* @param {CreateNextContextOptions} opts - options
*/
export const createContext = async (opts: CreateNextContextOptions) => {
const { req, res } = opts;
const sessionId = req.headers['x-session-id'] as string;
const cache = new TipiCache('createContext');
const userId = await cache.get(`session:${sessionId}`);
await cache.close();
return createContextInner({
req,
res,
sessionId,
userId: Number(userId) || undefined,
});
};
export type Context = inferAsyncReturnType<typeof createContext>;

17
src/server/routers/_app.ts
View file

@ -1,17 +0,0 @@
import { inferRouterInputs, inferRouterOutputs } from '@trpc/server';
import { router } from '../trpc';
import { appRouter } from './app/app.router';
import { authRouter } from './auth/auth.router';
import { systemRouter } from './system/system.router';
export const mainRouter = router({
system: systemRouter,
auth: authRouter,
app: appRouter,
});
// export type definition of API
export type AppRouter = typeof mainRouter;
export type RouterInput = inferRouterInputs<AppRouter>;
export type RouterOutput = inferRouterOutputs<AppRouter>;

27
src/server/routers/app/app.router.ts
View file

@ -1,27 +0,0 @@
import { z } from 'zod';
import { inferRouterOutputs } from '@trpc/server';
import { db } from '@/server/db';
import { AppServiceClass } from '../../services/apps/apps.service';
import { router, protectedProcedure } from '../../trpc';
export type AppRouterOutput = inferRouterOutputs<typeof appRouter>;
const AppService = new AppServiceClass(db);
const formSchema = z.object({}).catchall(z.any());
export const appRouter = router({
getApp: protectedProcedure.input(z.object({ id: z.string() })).query(({ input }) => AppService.getApp(input.id)),
startAllApp: protectedProcedure.mutation(AppService.startAllApps),
startApp: protectedProcedure.input(z.object({ id: z.string() })).mutation(({ input }) => AppService.startApp(input.id)),
installApp: protectedProcedure
.input(z.object({ id: z.string(), form: formSchema, exposed: z.boolean().optional(), domain: z.string().optional() }))
.mutation(({ input }) => AppService.installApp(input.id, input.form, input.exposed, input.domain)),
updateAppConfig: protectedProcedure
.input(z.object({ id: z.string(), form: formSchema, exposed: z.boolean().optional(), domain: z.string().optional() }))
.mutation(({ input }) => AppService.updateAppConfig(input.id, input.form, input.exposed, input.domain)),
stopApp: protectedProcedure.input(z.object({ id: z.string() })).mutation(({ input }) => AppService.stopApp(input.id)),
uninstallApp: protectedProcedure.input(z.object({ id: z.string() })).mutation(({ input }) => AppService.uninstallApp(input.id)),
updateApp: protectedProcedure.input(z.object({ id: z.string() })).mutation(({ input }) => AppService.updateApp(input.id)),
installedApps: protectedProcedure.query(AppService.installedApps),
listApps: protectedProcedure.query(() => AppServiceClass.listApps()),
});

11
src/server/routers/auth/auth.router.ts
View file

@ -1,11 +0,0 @@
import { z } from 'zod';
import { AuthServiceClass } from '../../services/auth/auth.service';
import { router, publicProcedure, protectedProcedure } from '../../trpc';
import { db } from '../../db';
const AuthService = new AuthServiceClass(db);
export const authRouter = router({
me: publicProcedure.query(async ({ ctx }) => AuthService.me(ctx.userId)),
changeLocale: protectedProcedure.input(z.object({ locale: z.string() })).mutation(async ({ input, ctx }) => AuthService.changeLocale({ userId: Number(ctx.userId), locale: input.locale })),
});

7
src/server/routers/routers.test.ts
View file

@ -1,7 +0,0 @@
import { mainRouter } from './_app';
describe('routers', () => {
it('should return a router', () => {
expect(mainRouter).toBeDefined();
});
});

16
src/server/routers/system/system.router.ts
View file

@ -1,16 +0,0 @@
import { inferRouterOutputs } from '@trpc/server';
import { settingsSchema } from '@runtipi/shared';
import { router, protectedProcedure, publicProcedure } from '../../trpc';
import { SystemServiceClass } from '../../services/system';
import * as TipiConfig from '../../core/TipiConfig';
export type SystemRouterOutput = inferRouterOutputs<typeof systemRouter>;
const SystemService = new SystemServiceClass();
export const systemRouter = router({
status: publicProcedure.query(SystemServiceClass.status),
getVersion: publicProcedure.query(SystemService.getVersion),
restart: protectedProcedure.mutation(SystemService.restart),
updateSettings: protectedProcedure.input(settingsSchema).mutation(({ input }) => TipiConfig.setSettings(input)),
getSettings: protectedProcedure.query(TipiConfig.getSettings),
});

2
src/server/services/apps/apps.service.ts
View file

@ -370,3 +370,5 @@ export class AppServiceClass {
.filter(notEmpty);
};
}
export type AppService = InstanceType<typeof AppServiceClass>;

72
src/server/trpc.ts
View file

@ -1,72 +0,0 @@
import { initTRPC, TRPCError } from '@trpc/server';
import superjson from 'superjson';
import { typeToFlattenedError, ZodError } from 'zod';
import { type Context } from './context';
import { AuthQueries } from './queries/auth/auth.queries';
import { db } from './db';
import { type MessageKey, TranslatedError } from './utils/errors';
const authQueries = new AuthQueries(db);
/**
* Convert ZodError to a record
*
* @param {typeToFlattenedError<string>} errors - errors
*/
function zodErrorsToRecord(errors: typeToFlattenedError<string>) {
const record: Record<string, string> = {};
Object.entries(errors.fieldErrors).forEach(([key, value]) => {
const error = value?.[0];
if (error) {
record[key] = error;
}
});
return record;
}
const t = initTRPC.context<Context>().create({
transformer: superjson,
errorFormatter({ shape, error }) {
return {
...shape,
data: {
...shape.data,
zodError: error.code === 'BAD_REQUEST' && error.cause instanceof ZodError ? zodErrorsToRecord(error.cause.flatten()) : null,
tError:
error.cause instanceof TranslatedError ? { message: error.cause.message as MessageKey, variables: error.cause.variableValues } : { message: error.message as MessageKey, variables: {} },
},
};
},
});
// Base router and procedure helpers
export const { router } = t;
/**
* Unprotected procedure
*/
export const publicProcedure = t.procedure;
/**
* Reusable middleware to ensure
* users are logged in
*/
const isAuthed = t.middleware(async ({ ctx, next }) => {
const { userId } = ctx;
if (!userId) {
throw new TRPCError({ code: 'UNAUTHORIZED', message: 'You need to be logged in to perform this action' });
}
const user = await authQueries.getUserById(userId);
if (!user) {
throw new TRPCError({ code: 'UNAUTHORIZED', message: 'You need to be logged in to perform this action' });
}
return next({ ctx });
});
/**
* Protected procedure
*/
export const protectedProcedure = t.procedure.use(isAuthed);

58
tests/TRPCTestClientProvider.tsx
View file

@ -1,58 +0,0 @@
import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
import { createTRPCReact, httpLink, loggerLink } from '@trpc/react-query';
import React, { useState } from 'react';
import fetch from 'isomorphic-fetch';
import superjson from 'superjson';
import type { AppRouter } from '../src/server/routers/_app';
export const trpc = createTRPCReact<AppRouter>({
unstable_overrides: {
useMutation: {
async onSuccess(opts) {
await opts.originalFn();
await opts.queryClient.invalidateQueries();
},
},
},
});
export function TRPCTestClientProvider(props: { children: React.ReactNode }) {
const { children } = props;
const [queryClient] = useState(
() =>
new QueryClient({
defaultOptions: {
queries: {
retry: false,
},
},
}),
);
const [trpcClient] = useState(() =>
trpc.createClient({
transformer: superjson,
links: [
loggerLink({
enabled: () => false,
}),
httpLink({
url: 'http://localhost:3000/api/trpc',
fetch: async (input, init?) =>
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore - isomorphic-fetch is missing the `signal` option
fetch(input, {
...init,
}),
}),
],
}),
);
return (
<trpc.Provider client={trpcClient} queryClient={queryClient}>
<QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
</trpc.Provider>
);
}

9
tests/test-utils.tsx
View file

@ -3,22 +3,19 @@ import { render, RenderOptions, renderHook } from '@testing-library/react';
import { Toaster } from 'react-hot-toast';
import { NextIntlProvider } from 'next-intl';
import ue from '@testing-library/user-event';
import { TRPCTestClientProvider } from './TRPCTestClientProvider';
import messages from '../src/client/messages/en.json';
const userEvent = ue.setup();
const AllTheProviders: FC<{ children: React.ReactNode }> = ({ children }) => (
<NextIntlProvider locale="en" messages={messages}>
<TRPCTestClientProvider>
{children}
<Toaster />
</TRPCTestClientProvider>
{children}
<Toaster />
</NextIntlProvider>
);
const customRender = (ui: ReactElement, options?: Omit<RenderOptions, 'wrapper'>) => render(ui, { wrapper: AllTheProviders, ...options });
const customRenderHook = (callback: () => any, options?: Omit<RenderOptions, 'wrapper'>) => renderHook(callback, { wrapper: AllTheProviders, ...options });
const customRenderHook = <Props, Result>(callback: (props: Props) => Result, options?: Omit<RenderOptions, 'wrapper'>) => renderHook(callback, { wrapper: AllTheProviders, ...options });
export * from '@testing-library/react';
export { customRender as render };