generator-kodly-react-app 1.0.7 → 1.0.11

package/generators/app/templates/src/router.tsx

@@ -1,8 +1,8 @@
 import { createRouter } from '@tanstack/react-router';
-import { routeTree } from './routeTree.gen';
+import { routeTree } from '@/routeTree.gen';
 
 export const router = createRouter({
-  basepath: import.meta.env.VITE_BASE || '/',
+  basepath: import.meta.env.BASE_URL,
   routeTree,
   context: {
     token: undefined!,

package/generators/app/templates/src/routes/__root.tsx

@@ -1,9 +1,9 @@
 import { Outlet, createRootRouteWithContext } from '@tanstack/react-router';
-import { AuthData } from '@/modules/auth/auth-types';
+import type { AuthResponseDtoUserDetailDto } from '@/sdk';
 
 interface RouterContext {
   token: string;
-  data: AuthData;
+  data: AuthResponseDtoUserDetailDto;
 }
 
 export const Route = createRootRouteWithContext<RouterContext>()({

package/generators/app/templates/src/routes/_landing/index.tsx

@@ -0,0 +1,10 @@
+import { createFileRoute } from '@tanstack/react-router';
+import { LandingPage } from '@/modules/landing/landing-page';
+
+export const Route = createFileRoute('/_landing/')({
+  component: RouteComponent,
+});
+
+function RouteComponent() {
+  return <LandingPage />;
+}

package/generators/app/templates/src/routes/_landing/route.tsx

@@ -0,0 +1,14 @@
+import { LandingPageLayout } from '@/modules/landing/layouts/landing-page-layout';
+import { createFileRoute, Outlet } from '@tanstack/react-router';
+
+export const Route = createFileRoute('/_landing')({
+  component: RouteComponent,
+});
+
+function RouteComponent() {
+  return (
+    <LandingPageLayout>
+      <Outlet />
+    </LandingPageLayout>
+  );
+}

package/generators/app/templates/src/routes/app/index.tsx

@@ -1,6 +1,4 @@
 import { createFileRoute } from '@tanstack/react-router';
-import { Button } from '@/components/ui/button';
-import { useLogout } from '@/modules/auth/use-auth-hook';
 import { useTranslation } from 'react-i18next';
 
 export const Route = createFileRoute('/app/')({
@@ -9,27 +7,12 @@ export const Route = createFileRoute('/app/')({
 
 function AppIndex() {
   const { t } = useTranslation();
-  const { mutate: logout, isPending } = useLogout();
-
-  const handleLogout = () => {
-    logout();
-  };
 
   return (
-    <div className='container mx-auto p-8'>
-      <div className='flex flex-col gap-6'>
-        <div>
-          <h1 className='text-3xl font-bold mb-4'>{t('welcome.title')}</h1>
-          <p className='text-muted-foreground'>{t('welcome.message')}</p>
-        </div>
-        <div>
-          <Button
-            onClick={handleLogout}
-            disabled={isPending}
-            variant='outline'>
-            {t('welcome.logout')}
-          </Button>
-        </div>
+    <div className='flex flex-col gap-6'>
+      <div>
+        <h1 className='text-3xl font-bold mb-4'>{t('app.welcome.title')}</h1>
+        <p className='text-muted-foreground'>{t('app.welcome.message')}</p>
       </div>
     </div>
   );

package/generators/app/templates/src/routes/app/route.tsx

@@ -1,18 +1,22 @@
-import { createFileRoute, Outlet, redirect } from "@tanstack/react-router";
-import { Route as LoginRoute } from "../auth/login";
+import { createFileRoute, Outlet, redirect } from '@tanstack/react-router';
+import { AppLayout } from '@/modules/app/layouts/app-layout';
+import { DEFAULT_NON_LOGGED_IN_ROUTE } from '@/lib/routes';
 
-export const Route = createFileRoute("/app")({
+export const Route = createFileRoute('/app')({
   beforeLoad: ({ context }) => {
     if (!context.token) {
       throw redirect({
-        to: LoginRoute.to,
+        to: DEFAULT_NON_LOGGED_IN_ROUTE,
       });
     }
   },
-  component: App,
+  component: RouteComponent,
 });
 
-function App() {
-  return <Outlet />;
+function RouteComponent() {
+  return (
+    <AppLayout>
+      <Outlet />
+    </AppLayout>
+  );
 }
-

package/generators/app/templates/src/routes/auth/forgot-password.tsx

@@ -0,0 +1,10 @@
+import { createFileRoute } from "@tanstack/react-router";
+import { ForgotPasswordForm } from '@/modules/auth/components/forgot-password-form';
+
+export const Route = createFileRoute("/auth/forgot-password")({
+  component: RouteComponent,
+});
+
+function RouteComponent() {
+  return <ForgotPasswordForm />;
+}

package/generators/app/templates/src/routes/auth/login.tsx

@@ -1,11 +1,10 @@
-import { createFileRoute } from "@tanstack/react-router";
-import { LoginPage } from "@/modules/auth/login/login-page";
+import { createFileRoute } from '@tanstack/react-router';
+import { LoginForm } from '@/modules/auth/components/login-form';
 
-export const Route = createFileRoute("/auth/login")({
-  component: App,
+export const Route = createFileRoute('/auth/login')({
+  component: RouteComponent,
 });
 
-function App() {
-  return <LoginPage />;
+function RouteComponent() {
+  return <LoginForm />;
 }
-

package/generators/app/templates/src/routes/auth/reset-password.tsx

@@ -0,0 +1,15 @@
+import { createFileRoute } from '@tanstack/react-router';
+import { ResetPasswordForm } from '@/modules/auth/components/reset-password-form';
+
+export const Route = createFileRoute('/auth/reset-password')({
+  component: RouteComponent,
+  validateSearch: (search: Record<string, unknown>) => {
+    return {
+      email: (search.email as string) || undefined,
+    };
+  },
+});
+
+function RouteComponent() {
+  return <ResetPasswordForm />;
+}

package/generators/app/templates/src/routes/auth/route.tsx

@@ -1,18 +1,35 @@
-import { createFileRoute, Outlet, redirect } from "@tanstack/react-router";
-import { Route as AppRoute } from "../app";
+import { createFileRoute, Outlet, redirect, useNavigate } from '@tanstack/react-router';
+import { AuthLayout } from '@/modules/auth/layouts/auth-layout';
+import { DEFAULT_LOGGED_IN_ROUTE } from '@/lib/routes';
+import { useAtomValue } from 'jotai';
+import { authTokenAtom } from '@/modules/auth/hooks/use-auth-hook';
+import { useEffect } from 'react';
 
-export const Route = createFileRoute("/auth")({
+export const Route = createFileRoute('/auth')({
   component: RouteComponent,
   beforeLoad: ({ context }) => {
     if (context.token) {
       throw redirect({
-        to: AppRoute.to,
+        to: DEFAULT_LOGGED_IN_ROUTE,
       });
     }
   },
 });
 
 function RouteComponent() {
-  return <Outlet />;
-}
+  const token = useAtomValue(authTokenAtom);
+  const navigate = useNavigate();
+
+  // Navigate after successful authentication
+  useEffect(() => {
+    if (token) {
+      navigate({ to: DEFAULT_LOGGED_IN_ROUTE, replace: true });
+    }
+  }, [token, navigate]);
 
+  return (
+    <AuthLayout>
+      <Outlet />
+    </AuthLayout>
+  );
+}

package/generators/app/templates/src/routes/auth/signup.tsx

@@ -0,0 +1,11 @@
+import { createFileRoute } from "@tanstack/react-router";
+import { SignupForm } from '@/modules/auth/components/signup-form';
+
+export const Route = createFileRoute("/auth/signup")({
+  component: RouteComponent,
+});
+
+function RouteComponent() {
+  return <SignupForm />;
+}
+

package/generators/app/templates/src/sdk/@tanstack/react-query.gen.ts

@@ -0,0 +1,91 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import type { DefaultError, UseMutationOptions } from '@tanstack/react-query';
+import type { AxiosError } from 'axios';
+
+import { loginUserAuth, logoutUserAuth, type Options, registerUserAuth, resetPasswordUserAuth, sendOtpUserAuth, validateTokenUserAuth } from '../sdk.gen';
+import type { LoginUserAuthData, LoginUserAuthResponse, LogoutUserAuthData, LogoutUserAuthResponse, RegisterUserAuthData, RegisterUserAuthResponse, ResetPasswordUserAuthData, ResetPasswordUserAuthResponse, SendOtpUserAuthData, SendOtpUserAuthResponse, ValidateTokenUserAuthData, ValidateTokenUserAuthResponse } from '../types.gen';
+
+export const validateTokenUserAuthMutation = (options?: Partial<Options<ValidateTokenUserAuthData>>): UseMutationOptions<ValidateTokenUserAuthResponse, AxiosError<DefaultError>, Options<ValidateTokenUserAuthData>> => {
+    const mutationOptions: UseMutationOptions<ValidateTokenUserAuthResponse, AxiosError<DefaultError>, Options<ValidateTokenUserAuthData>> = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await validateTokenUserAuth({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+
+export const sendOtpUserAuthMutation = (options?: Partial<Options<SendOtpUserAuthData>>): UseMutationOptions<SendOtpUserAuthResponse, AxiosError<DefaultError>, Options<SendOtpUserAuthData>> => {
+    const mutationOptions: UseMutationOptions<SendOtpUserAuthResponse, AxiosError<DefaultError>, Options<SendOtpUserAuthData>> = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await sendOtpUserAuth({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+
+export const resetPasswordUserAuthMutation = (options?: Partial<Options<ResetPasswordUserAuthData>>): UseMutationOptions<ResetPasswordUserAuthResponse, AxiosError<DefaultError>, Options<ResetPasswordUserAuthData>> => {
+    const mutationOptions: UseMutationOptions<ResetPasswordUserAuthResponse, AxiosError<DefaultError>, Options<ResetPasswordUserAuthData>> = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await resetPasswordUserAuth({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+
+export const registerUserAuthMutation = (options?: Partial<Options<RegisterUserAuthData>>): UseMutationOptions<RegisterUserAuthResponse, AxiosError<DefaultError>, Options<RegisterUserAuthData>> => {
+    const mutationOptions: UseMutationOptions<RegisterUserAuthResponse, AxiosError<DefaultError>, Options<RegisterUserAuthData>> = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await registerUserAuth({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+
+export const logoutUserAuthMutation = (options?: Partial<Options<LogoutUserAuthData>>): UseMutationOptions<LogoutUserAuthResponse, AxiosError<DefaultError>, Options<LogoutUserAuthData>> => {
+    const mutationOptions: UseMutationOptions<LogoutUserAuthResponse, AxiosError<DefaultError>, Options<LogoutUserAuthData>> = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await logoutUserAuth({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};
+
+export const loginUserAuthMutation = (options?: Partial<Options<LoginUserAuthData>>): UseMutationOptions<LoginUserAuthResponse, AxiosError<DefaultError>, Options<LoginUserAuthData>> => {
+    const mutationOptions: UseMutationOptions<LoginUserAuthResponse, AxiosError<DefaultError>, Options<LoginUserAuthData>> = {
+        mutationFn: async (fnOptions) => {
+            const { data } = await loginUserAuth({
+                ...options,
+                ...fnOptions,
+                throwOnError: true
+            });
+            return data;
+        }
+    };
+    return mutationOptions;
+};

package/generators/app/templates/src/sdk/client/client.gen.ts

@@ -0,0 +1,167 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import type { AxiosError, AxiosInstance, RawAxiosRequestHeaders } from 'axios';
+import axios from 'axios';
+
+import { createSseClient } from '../core/serverSentEvents.gen';
+import type { HttpMethod } from '../core/types.gen';
+import { getValidRequestBody } from '../core/utils.gen';
+import type { Client, Config, RequestOptions } from './types.gen';
+import {
+  buildUrl,
+  createConfig,
+  mergeConfigs,
+  mergeHeaders,
+  setAuthParams,
+} from './utils.gen';
+
+export const createClient = (config: Config = {}): Client => {
+  let _config = mergeConfigs(createConfig(), config);
+
+  let instance: AxiosInstance;
+
+  if (_config.axios && !('Axios' in _config.axios)) {
+    instance = _config.axios;
+  } else {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { auth, ...configWithoutAuth } = _config;
+    instance = axios.create(configWithoutAuth);
+  }
+
+  const getConfig = (): Config => ({ ..._config });
+
+  const setConfig = (config: Config): Config => {
+    _config = mergeConfigs(_config, config);
+    instance.defaults = {
+      ...instance.defaults,
+      ..._config,
+      // @ts-expect-error
+      headers: mergeHeaders(instance.defaults.headers, _config.headers),
+    };
+    return getConfig();
+  };
+
+  const beforeRequest = async (options: RequestOptions) => {
+    const opts = {
+      ..._config,
+      ...options,
+      axios: options.axios ?? _config.axios ?? instance,
+      headers: mergeHeaders(_config.headers, options.headers),
+    };
+
+    if (opts.security) {
+      await setAuthParams({
+        ...opts,
+        security: opts.security,
+      });
+    }
+
+    if (opts.requestValidator) {
+      await opts.requestValidator(opts);
+    }
+
+    if (opts.body !== undefined && opts.bodySerializer) {
+      opts.body = opts.bodySerializer(opts.body);
+    }
+
+    const url = buildUrl(opts);
+
+    return { opts, url };
+  };
+
+  // @ts-expect-error
+  const request: Client['request'] = async (options) => {
+    // @ts-expect-error
+    const { opts, url } = await beforeRequest(options);
+    try {
+      // assign Axios here for consistency with fetch
+      const _axios = opts.axios!;
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      const { auth, ...optsWithoutAuth } = opts;
+      const response = await _axios({
+        ...optsWithoutAuth,
+        baseURL: '', // the baseURL is already included in `url`
+        data: getValidRequestBody(opts),
+        headers: opts.headers as RawAxiosRequestHeaders,
+        // let `paramsSerializer()` handle query params if it exists
+        params: opts.paramsSerializer ? opts.query : undefined,
+        url,
+      });
+
+      let { data } = response;
+
+      if (opts.responseType === 'json') {
+        if (opts.responseValidator) {
+          await opts.responseValidator(data);
+        }
+
+        if (opts.responseTransformer) {
+          data = await opts.responseTransformer(data);
+        }
+      }
+
+      return {
+        ...response,
+        data: data ?? {},
+      };
+    } catch (error) {
+      const e = error as AxiosError;
+      if (opts.throwOnError) {
+        throw e;
+      }
+      // @ts-expect-error
+      e.error = e.response?.data ?? {};
+      return e;
+    }
+  };
+
+  const makeMethodFn =
+    (method: Uppercase<HttpMethod>) => (options: RequestOptions) =>
+      request({ ...options, method });
+
+  const makeSseFn =
+    (method: Uppercase<HttpMethod>) => async (options: RequestOptions) => {
+      const { opts, url } = await beforeRequest(options);
+      return createSseClient({
+        ...opts,
+        body: opts.body as BodyInit | null | undefined,
+        headers: opts.headers as Record<string, string>,
+        method,
+        serializedBody: getValidRequestBody(opts) as
+          | BodyInit
+          | null
+          | undefined,
+        // @ts-expect-error
+        signal: opts.signal,
+        url,
+      });
+    };
+
+  return {
+    buildUrl,
+    connect: makeMethodFn('CONNECT'),
+    delete: makeMethodFn('DELETE'),
+    get: makeMethodFn('GET'),
+    getConfig,
+    head: makeMethodFn('HEAD'),
+    instance,
+    options: makeMethodFn('OPTIONS'),
+    patch: makeMethodFn('PATCH'),
+    post: makeMethodFn('POST'),
+    put: makeMethodFn('PUT'),
+    request,
+    setConfig,
+    sse: {
+      connect: makeSseFn('CONNECT'),
+      delete: makeSseFn('DELETE'),
+      get: makeSseFn('GET'),
+      head: makeSseFn('HEAD'),
+      options: makeSseFn('OPTIONS'),
+      patch: makeSseFn('PATCH'),
+      post: makeSseFn('POST'),
+      put: makeSseFn('PUT'),
+      trace: makeSseFn('TRACE'),
+    },
+    trace: makeMethodFn('TRACE'),
+  } as Client;
+};

package/generators/app/templates/src/sdk/client/index.ts

@@ -0,0 +1,23 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+export type { Auth } from '../core/auth.gen';
+export type { QuerySerializerOptions } from '../core/bodySerializer.gen';
+export {
+  formDataBodySerializer,
+  jsonBodySerializer,
+  urlSearchParamsBodySerializer,
+} from '../core/bodySerializer.gen';
+export { buildClientParams } from '../core/params.gen';
+export { serializeQueryKeyValue } from '../core/queryKeySerializer.gen';
+export { createClient } from './client.gen';
+export type {
+  Client,
+  ClientOptions,
+  Config,
+  CreateClientConfig,
+  Options,
+  RequestOptions,
+  RequestResult,
+  TDataShape,
+} from './types.gen';
+export { createConfig } from './utils.gen';