subaya 1.0.1 → 1.0.2

package/dist/template/axios/instance.d.ts

@@ -1,2 +1,4 @@
-export declare const axiosInstance: (noRefresh: boolean) => string;
+export declare const axiosInstanceWithLocalStorageRefreshToken = "import axios, { AxiosError, AxiosInstance, AxiosRequestConfig } from \"axios\"\nimport qs from \"qs\"\n\nimport { ENV } from \"@/configs/env\"\nimport { apiLogger } from \"@/utils/logger/api-logger\"\nimport styledConsole from \"@/utils/logger/styled-console\"\nimport { tokenStorage } from \"@/store/local/index\"\nimport { refresh } from \"./refresh\"\n\nconst isDev = ENV.NODE_ENV === \"development\"\n\nexport class HttpClient {\n  private instance: AxiosInstance\n\n  constructor(config?: AxiosRequestConfig) {\n    this.instance = axios.create({\n      baseURL: ENV.API_BASE_URL,\n      timeout: 5000,\n      headers: {\n        \"Content-Type\": \"application/json\",\n      },\n      ...config,\n    })\n    this.setupInterceptors()\n  }\n\n  private setupInterceptors() {\n    this.instance.interceptors.request.use(\n      (config) => {\n        const token = tokenStorage?.get()\n        const isAccess = !!token && !!token.access\n        if (isAccess) {\n          config.headers.setAuthorization(`Bearer ${token.access}`);\n        }\n        return config\n      },\n      (error) => {\n        return Promise.reject(error)\n      },\n    )\n\n    this.instance.interceptors.response.use(\n      (res) => {\n        const { status, config: reqData, data: resData } = res\n        if (isDev) apiLogger({ status, reqData, resData })\n        return res\n      },\n      async (error: AxiosError) => {\n        try {\n          const { response: res, config: reqData } = error || {}\n          const { status } = res || { status: 400 }\n          const isUnAuthError = status === 401\n          const isExpiredToken = status === 444\n\n          if (isDev) apiLogger({ status, reqData, resData: error, method: \"error\" })\n\n          if (isExpiredToken && reqData) {\n            const refreshedConfig = await refresh(reqData)\n            if (refreshedConfig) {\n              return this.instance.request(refreshedConfig)\n            }\n          }\n\n          if (isUnAuthError) {\n            tokenStorage?.remove()\n          }\n\n          return Promise.reject(error)\n        } catch (e) {\n          styledConsole({\n            method: \"error\",\n            topic: \"UN_HANDLED\",\n            title: \"axios-interceptor\",\n            data: e,\n          })\n          return Promise.reject(e)\n        }\n      },\n    )\n\n    this.instance.defaults.paramsSerializer = (params) => {\n      return qs.stringify(params, { arrayFormat: \"repeat\" })\n    }\n  }\n\n  public getInstance(): AxiosInstance {\n    return this.instance\n  }\n}\n\nexport const instance = new HttpClient().getInstance()";
+export declare const axiosInstanceWithNextServerJwt = "import axios, { AxiosError, AxiosInstance, AxiosRequestConfig } from \"axios\"\nimport qs from \"qs\"\n\nimport { ENV } from \"@/configs/env\"\nimport { apiLogger } from \"@/utils/logger/api-logger\"\nimport styledConsole from \"@/utils/logger/styled-console\"\nimport { clearTokens } from \"@/utils/jwt\"\n\nconst isDev = ENV.NODE_ENV === \"development\"\n\nlet isRefreshing = false;\nlet refreshSubscribers: ((token: string) => void)[] = [];\n\nconst onRefreshed = (token: string) => {\n  refreshSubscribers.forEach((callback) => callback(token));\n  refreshSubscribers = [];\n};\n\nconst addRefreshSubscriber = (callback: (token: string) => void) => {\n  refreshSubscribers.push(callback);\n};\n\nexport class HttpClient {\n  private instance: AxiosInstance\n\n  constructor(config?: AxiosRequestConfig) {\n    this.instance = axios.create({\n      baseURL: ENV.API_BASE_URL,\n      timeout: 5000,\n      withCredentials: true, \n      headers: {\n        \"Content-Type\": \"application/json\",\n      },\n      ...config,\n    })\n    this.setupInterceptors()\n  }\n\n  private setupInterceptors() {\n    this.instance.interceptors.request.use(\n      (config) => config,\n      (error) => Promise.reject(error),\n    )\n\n    this.instance.interceptors.response.use(\n      (res) => {\n        const { status, config: reqData, data: resData } = res\n        if (isDev) apiLogger({ status, reqData, resData })\n        return res\n      },\n      async (error: AxiosError) => {\n        const { response: res, config: reqData } = error || {}\n        const { status } = res || { status: 400 }\n        const originalRequest = reqData as AxiosRequestConfig & { _retry?: boolean }\n        const isBrowser = typeof window !== 'undefined'\n        const isUnAuthError = status === 401\n        const isExpiredToken = status === 444\n\n        if (isExpiredToken && originalRequest && !originalRequest._retry && isBrowser) {\n          originalRequest._retry = true;\n\n          if (isRefreshing) {\n            return new Promise((resolve) => {\n              addRefreshSubscriber(() => {\n                resolve(this.instance(originalRequest));\n              });\n            });\n          }\n\n          isRefreshing = true;\n\n          try {\n            await axios.post('/api/auth/refresh'); \n            \n            isRefreshing = false;\n            onRefreshed('success');\n            return this.instance(originalRequest);\n          } catch (refreshError) {\n            isRefreshing = false;\n            refreshSubscribers = [];\n            if (typeof window !== 'undefined') {\n              window.location.href = '/login'; \n            }\n            return Promise.reject(refreshError);\n          }\n        }\n\n        if (isUnAuthError) {\n          await clearTokens();\n        }\n\n        styledConsole({\n          method: \"error\",\n          topic: \"UN_HANDLED\",\n          title: \"axios-interceptor\",\n          data: error,\n        })\n        return Promise.reject(error)\n      },\n    )\n\n    this.instance.defaults.paramsSerializer = (params) => {\n      return qs.stringify(params, { arrayFormat: \"repeat\" })\n    }\n  }\n\n  public getInstance(): AxiosInstance {\n    return this.instance\n  }\n}\n\nexport const instance = new HttpClient().getInstance()";
+export declare const axiosInstance = "import axios, { AxiosError, AxiosInstance, AxiosRequestConfig } from \"axios\"\nimport qs from \"qs\"\n\nimport { ENV } from \"@/configs/env\"\nimport { apiLogger } from \"@/utils/logger/api-logger\"\nimport styledConsole from \"@/utils/logger/styled-console\"\n\nconst isDev = ENV.NODE_ENV === \"development\"\n\nexport class HttpClient {\n  private instance: AxiosInstance\n\n  constructor(config?: AxiosRequestConfig) {\n    this.instance = axios.create({\n      baseURL: ENV.API_BASE_URL,\n      timeout: 5000,\n      headers: {\n        \"Content-Type\": \"application/json\",\n      },\n      ...config,\n    })\n    this.setupInterceptors()\n  }\n\n  private setupInterceptors() {\n    this.instance.interceptors.request.use(\n      (config) => {\n        return config\n      },\n      (error) => {\n        return Promise.reject(error)\n      },\n    )\n\n    this.instance.interceptors.response.use(\n      (res) => {\n        const { status, config: reqData, data: resData } = res\n        if (isDev) apiLogger({ status, reqData, resData })\n        return res\n      },\n      async (error: AxiosError) => {\n        try {\n          const { response: res, config: reqData } = error || {}\n          const { status } = res || { status: 400 }\n\n          if (isDev) apiLogger({ status, reqData, resData: error, method: \"error\" })\n\n          return Promise.reject(error)\n        } catch (e) {\n          styledConsole({\n            method: \"error\",\n            topic: \"UN_HANDLED\",\n            title: \"axios-interceptor\",\n            data: e,\n          })\n          return Promise.reject(e)\n        }\n      },\n    )\n\n    this.instance.defaults.paramsSerializer = (params) => {\n      return qs.stringify(params, { arrayFormat: \"repeat\" })\n    }\n  }\n\n  public getInstance(): AxiosInstance {\n    return this.instance\n  }\n}\n\nexport const instance = new HttpClient().getInstance()\n";
 //# sourceMappingURL=instance.d.ts.map

package/dist/template/axios/instance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"instance.d.ts","sourceRoot":"","sources":["../../../src/template/axios/instance.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa,GACxB,WAAW,OAAO,WA0FmC,CAAA"}
+{"version":3,"file":"instance.d.ts","sourceRoot":"","sources":["../../../src/template/axios/instance.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,yCAAyC,skFA0FC,CAAA;AAEvD,eAAO,MAAM,8BAA8B,ovGA+GY,CAAA;AAEvD,eAAO,MAAM,aAAa,u4DAuEzB,CAAA"}

package/dist/template/axios/instance.js

@@ -1,11 +1,12 @@
-export const axiosInstance = (noRefresh) => `import axios, { AxiosError, AxiosInstance, AxiosRequestConfig } from "axios"
+export const axiosInstanceWithLocalStorageRefreshToken = `import axios, { AxiosError, AxiosInstance, AxiosRequestConfig } from "axios"
 import qs from "qs"
 
 import { ENV } from "@/configs/env"
 import { apiLogger } from "@/utils/logger/api-logger"
 import styledConsole from "@/utils/logger/styled-console"
-${!noRefresh ? `import { tokenStorage } from "@/store/local/index"` : ""}
-${!noRefresh ? `import { refresh } from "./refresh"\n` : ""}
+import { tokenStorage } from "@/store/local/index"
+import { refresh } from "./refresh"
+
 const isDev = ENV.NODE_ENV === "development"
 
 export class HttpClient {
@@ -26,11 +27,11 @@ export class HttpClient {
   private setupInterceptors() {
     this.instance.interceptors.request.use(
       (config) => {
-        ${noRefresh ? "// " : ""}const token = tokenStorage?.get()
-        ${noRefresh ? "// " : ""}const isAccess = !!token && !!token.access
-        ${noRefresh ? "// " : ""}if (isAccess) {
-        ${noRefresh ? "// " : ""}  config.headers.setAuthorization(\`Bearer \${token.access}\`)
-        ${noRefresh ? "// " : ""}}
+        const token = tokenStorage?.get()
+        const isAccess = !!token && !!token.access
+        if (isAccess) {
+          config.headers.setAuthorization(\`Bearer \${token.access}\`);
+        }
         return config
       },
       (error) => {
@@ -48,21 +49,21 @@ export class HttpClient {
         try {
           const { response: res, config: reqData } = error || {}
           const { status } = res || { status: 400 }
-          ${noRefresh ? "// " : ""}const isUnAuthError = status === 401
-          ${noRefresh ? "// " : ""}const isExpiredToken = status === 444
+          const isUnAuthError = status === 401
+          const isExpiredToken = status === 444
 
           if (isDev) apiLogger({ status, reqData, resData: error, method: "error" })
 
-          ${noRefresh ? "// " : ""}if (isExpiredToken && reqData) {
-          ${noRefresh ? "// " : ""}  const refreshedConfig = await refresh(reqData)
-          ${noRefresh ? "// " : ""}  if (refreshedConfig) {
-          ${noRefresh ? "// " : ""}    return this.instance.request(refreshedConfig)
-          ${noRefresh ? "// " : ""}  }
-          ${noRefresh ? "// " : ""}}
+          if (isExpiredToken && reqData) {
+            const refreshedConfig = await refresh(reqData)
+            if (refreshedConfig) {
+              return this.instance.request(refreshedConfig)
+            }
+          }
 
-          ${noRefresh ? "// " : ""}if (isUnAuthError) {
-          ${noRefresh ? "// " : ""}  tokenStorage?.remove()
-          ${noRefresh ? "// " : ""}}
+          if (isUnAuthError) {
+            tokenStorage?.remove()
+          }
 
           return Promise.reject(error)
         } catch (e) {
@@ -88,4 +89,188 @@ export class HttpClient {
 }
 
 export const instance = new HttpClient().getInstance()`;
+export const axiosInstanceWithNextServerJwt = `import axios, { AxiosError, AxiosInstance, AxiosRequestConfig } from "axios"
+import qs from "qs"
+
+import { ENV } from "@/configs/env"
+import { apiLogger } from "@/utils/logger/api-logger"
+import styledConsole from "@/utils/logger/styled-console"
+import { clearTokens } from "@/utils/jwt"
+
+const isDev = ENV.NODE_ENV === "development"
+
+let isRefreshing = false;
+let refreshSubscribers: ((token: string) => void)[] = [];
+
+const onRefreshed = (token: string) => {
+  refreshSubscribers.forEach((callback) => callback(token));
+  refreshSubscribers = [];
+};
+
+const addRefreshSubscriber = (callback: (token: string) => void) => {
+  refreshSubscribers.push(callback);
+};
+
+export class HttpClient {
+  private instance: AxiosInstance
+
+  constructor(config?: AxiosRequestConfig) {
+    this.instance = axios.create({
+      baseURL: ENV.API_BASE_URL,
+      timeout: 5000,
+      withCredentials: true, 
+      headers: {
+        "Content-Type": "application/json",
+      },
+      ...config,
+    })
+    this.setupInterceptors()
+  }
+
+  private setupInterceptors() {
+    this.instance.interceptors.request.use(
+      (config) => config,
+      (error) => Promise.reject(error),
+    )
+
+    this.instance.interceptors.response.use(
+      (res) => {
+        const { status, config: reqData, data: resData } = res
+        if (isDev) apiLogger({ status, reqData, resData })
+        return res
+      },
+      async (error: AxiosError) => {
+        const { response: res, config: reqData } = error || {}
+        const { status } = res || { status: 400 }
+        const originalRequest = reqData as AxiosRequestConfig & { _retry?: boolean }
+        const isBrowser = typeof window !== 'undefined'
+        const isUnAuthError = status === 401
+        const isExpiredToken = status === 444
+
+        if (isExpiredToken && originalRequest && !originalRequest._retry && isBrowser) {
+          originalRequest._retry = true;
+
+          if (isRefreshing) {
+            return new Promise((resolve) => {
+              addRefreshSubscriber(() => {
+                resolve(this.instance(originalRequest));
+              });
+            });
+          }
+
+          isRefreshing = true;
+
+          try {
+            await axios.post('/api/auth/refresh'); 
+            
+            isRefreshing = false;
+            onRefreshed('success');
+            return this.instance(originalRequest);
+          } catch (refreshError) {
+            isRefreshing = false;
+            refreshSubscribers = [];
+            if (typeof window !== 'undefined') {
+              window.location.href = '/login'; 
+            }
+            return Promise.reject(refreshError);
+          }
+        }
+
+        if (isUnAuthError) {
+          await clearTokens();
+        }
+
+        styledConsole({
+          method: "error",
+          topic: "UN_HANDLED",
+          title: "axios-interceptor",
+          data: error,
+        })
+        return Promise.reject(error)
+      },
+    )
+
+    this.instance.defaults.paramsSerializer = (params) => {
+      return qs.stringify(params, { arrayFormat: "repeat" })
+    }
+  }
+
+  public getInstance(): AxiosInstance {
+    return this.instance
+  }
+}
+
+export const instance = new HttpClient().getInstance()`;
+export const axiosInstance = `import axios, { AxiosError, AxiosInstance, AxiosRequestConfig } from "axios"
+import qs from "qs"
+
+import { ENV } from "@/configs/env"
+import { apiLogger } from "@/utils/logger/api-logger"
+import styledConsole from "@/utils/logger/styled-console"
+
+const isDev = ENV.NODE_ENV === "development"
+
+export class HttpClient {
+  private instance: AxiosInstance
+
+  constructor(config?: AxiosRequestConfig) {
+    this.instance = axios.create({
+      baseURL: ENV.API_BASE_URL,
+      timeout: 5000,
+      headers: {
+        "Content-Type": "application/json",
+      },
+      ...config,
+    })
+    this.setupInterceptors()
+  }
+
+  private setupInterceptors() {
+    this.instance.interceptors.request.use(
+      (config) => {
+        return config
+      },
+      (error) => {
+        return Promise.reject(error)
+      },
+    )
+
+    this.instance.interceptors.response.use(
+      (res) => {
+        const { status, config: reqData, data: resData } = res
+        if (isDev) apiLogger({ status, reqData, resData })
+        return res
+      },
+      async (error: AxiosError) => {
+        try {
+          const { response: res, config: reqData } = error || {}
+          const { status } = res || { status: 400 }
+
+          if (isDev) apiLogger({ status, reqData, resData: error, method: "error" })
+
+          return Promise.reject(error)
+        } catch (e) {
+          styledConsole({
+            method: "error",
+            topic: "UN_HANDLED",
+            title: "axios-interceptor",
+            data: e,
+          })
+          return Promise.reject(e)
+        }
+      },
+    )
+
+    this.instance.defaults.paramsSerializer = (params) => {
+      return qs.stringify(params, { arrayFormat: "repeat" })
+    }
+  }
+
+  public getInstance(): AxiosInstance {
+    return this.instance
+  }
+}
+
+export const instance = new HttpClient().getInstance()
+`;
 //# sourceMappingURL=instance.js.map

package/dist/template/axios/instance.js.map

@@ -1 +1 @@
-{"version":3,"file":"instance.js","sourceRoot":"","sources":["../../../src/template/axios/instance.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,aAAa,GAAG,CAC3B,SAAkB,EAClB,EAAE,CAAC;;;;;;EAMH,CAAC,SAAS,CAAC,CAAC,CAAC,oDAAoD,CAAC,CAAC,CAAC,EAAE;EACtE,CAAC,SAAS,CAAC,CAAC,CAAC,uCAAuC,CAAC,CAAC,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;UAqBjD,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE;UACtB,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE;UACtB,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE;UACtB,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE;UACtB,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE;;;;;;;;;;;;;;;;;;YAkBpB,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE;YACtB,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE;;;;YAItB,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE;YACtB,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE;YACtB,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE;YACtB,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE;YACtB,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE;YACtB,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE;;YAEtB,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE;YACtB,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE;YACtB,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;uDAyBqB,CAAA"}
+{"version":3,"file":"instance.js","sourceRoot":"","sources":["../../../src/template/axios/instance.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,yCAAyC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uDA0FF,CAAA;AAEvD,MAAM,CAAC,MAAM,8BAA8B,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uDA+GS,CAAA;AAEvD,MAAM,CAAC,MAAM,aAAa,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuE5B,CAAA"}

package/dist/template/axios/nextServerJwt.d.ts

@@ -0,0 +1,4 @@
+export declare const nextServerAuthLoginRoute: () => string;
+export declare const nextServerAuthRefreshRoute: () => string;
+export declare const nextServerAuthLogoutRoute: () => string;
+//# sourceMappingURL=nextServerJwt.d.ts.map

package/dist/template/axios/nextServerJwt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nextServerJwt.d.ts","sourceRoot":"","sources":["../../../src/template/axios/nextServerJwt.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,wBAAwB,cAuBpC,CAAA;AAED,eAAO,MAAM,0BAA0B,cA0BtC,CAAA;AAED,eAAO,MAAM,yBAAyB,cAOrC,CAAA"}

package/dist/template/axios/nextServerJwt.js

@@ -0,0 +1,60 @@
+export const nextServerAuthLoginRoute = () => `import { instance } from "@/configs/axios/instance"
+import { AUTH_ENDPOINTS, setTokens } from "@/utils/jwt"
+import { NextResponse } from "next/server"
+
+export async function POST(request: Request) {
+  try {
+    const body = await request.json()
+
+    const response = await instance.post(AUTH_ENDPOINTS.LOGIN, body)
+    
+    const { accessToken, refreshToken, ...userData } = response.data 
+
+    await setTokens(accessToken, refreshToken)
+
+    return NextResponse.json({ success: true, user: userData })
+
+  } catch (error: any) {
+    const status = error.response?.status || 500
+    const errorData = error.response?.data || { message: 'Login failed' }
+    
+    return NextResponse.json(errorData, { status })
+  }
+}
+`;
+export const nextServerAuthRefreshRoute = () => `import { instance } from "@/configs/axios/instance"
+import { AUTH_ENDPOINTS, getTokens, setTokens, clearTokens } from "@/utils/jwt"
+import { NextResponse } from "next/server"
+
+export async function POST() {
+  const { refreshToken } = await getTokens()
+
+  if (!refreshToken) {
+    return NextResponse.json({ message: 'No refresh token' }, { status: 401 })
+  }
+
+  try {
+    const response = await instance.post(AUTH_ENDPOINTS.REFRESH, { 
+      refresh: refreshToken 
+    })
+    
+    const { accessToken, refreshToken: newRefreshToken } = response.data
+
+    await setTokens(accessToken, newRefreshToken)
+
+    return NextResponse.json({ success: true })
+  } catch {
+    await clearTokens()
+    return NextResponse.json({ message: 'Refresh failed' }, { status: 401 })
+  }
+}
+`;
+export const nextServerAuthLogoutRoute = () => `import { NextResponse } from 'next/server'
+import { clearTokens } from '@/utils/jwt'
+
+export async function POST() {
+  await clearTokens()
+  return NextResponse.json({ success: true })
+}
+`;
+//# sourceMappingURL=nextServerJwt.js.map

package/dist/template/axios/nextServerJwt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nextServerJwt.js","sourceRoot":"","sources":["../../../src/template/axios/nextServerJwt.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,wBAAwB,GAAG,GAAG,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;;CAuB7C,CAAA;AAED,MAAM,CAAC,MAAM,0BAA0B,GAAG,GAAG,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;CA0B/C,CAAA;AAED,MAAM,CAAC,MAAM,yBAAyB,GAAG,GAAG,EAAE,CAAC;;;;;;;CAO9C,CAAA"}

package/dist/template/axios/protectedProxy.d.ts

@@ -0,0 +1,2 @@
+export declare const protectedProxy: () => string;
+//# sourceMappingURL=protectedProxy.d.ts.map

package/dist/template/axios/protectedProxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protectedProxy.d.ts","sourceRoot":"","sources":["../../../src/template/axios/protectedProxy.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,cAsC1B,CAAA"}

package/dist/template/axios/protectedProxy.js

@@ -0,0 +1,40 @@
+export const protectedProxy = () => `import { NextResponse } from 'next/server';
+import type { NextRequest } from 'next/server';
+import { TOKEN_KEYS } from '@/utils/jwt';
+import { PROTECTED_ROUTES, ROUTES } from '@/generated/path/routes';
+
+export function proxy(request: NextRequest) {
+  const { pathname } = request.nextUrl;
+
+  const isProtectedRoute = PROTECTED_ROUTES.some((route) =>
+    pathname.startsWith(route)
+  );
+
+  if (isProtectedRoute) {
+    const hasAccessToken = request.cookies.has(TOKEN_KEYS.ACCESS);
+    const hasRefreshToken = request.cookies.has(TOKEN_KEYS.REFRESH);
+
+    if (!hasAccessToken && !hasRefreshToken) {
+      const loginUrl = new URL(ROUTES.LOGIN, request.url);
+      loginUrl.searchParams.set('redirect', pathname); 
+      return NextResponse.redirect(loginUrl);
+    }
+  }
+
+  if (pathname === ROUTES.LOGIN) {
+    const hasRefreshToken = request.cookies.has(TOKEN_KEYS.REFRESH);
+    if (hasRefreshToken) {
+      return NextResponse.redirect(new URL(ROUTES.HOME, request.url));
+    }
+  }
+
+  return NextResponse.next();
+}
+
+export const config = {
+  matcher: [
+    '/((?!api|_next/static|_next/image|favicon.ico).*)',
+  ],
+};
+`;
+//# sourceMappingURL=protectedProxy.js.map

package/dist/template/axios/protectedProxy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"protectedProxy.js","sourceRoot":"","sources":["../../../src/template/axios/protectedProxy.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,cAAc,GAAG,GAAG,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsCnC,CAAA"}

package/dist/template/axios/useLoginHook.d.ts

@@ -0,0 +1,2 @@
+export declare const useLoginHook: () => string;
+//# sourceMappingURL=useLoginHook.d.ts.map

package/dist/template/axios/useLoginHook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLoginHook.d.ts","sourceRoot":"","sources":["../../../src/template/axios/useLoginHook.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY,cAexB,CAAA"}

package/dist/template/axios/useLoginHook.js

@@ -0,0 +1,16 @@
+export const useLoginHook = () => `import { CommonErrorType, UserLoginRequestType, UserLoginType } from "@/generated/api/@types/data-contracts"
+import { useMutation } from "@tanstack/react-query"
+import axios, { AxiosError } from "axios"
+
+export const useLoginMutation = () => {
+  // TODO: Change to the actual login type from the API
+  return useMutation<UserLoginType, AxiosError<CommonErrorType>, UserLoginRequestType>({
+    mutationKey: ["AUTH_JWT_LOGIN_CREATE"],
+    mutationFn: async (data) => {
+      const res = await axios.post("/api/auth/login", data)
+      return res.data
+    },
+  })
+}
+`;
+//# sourceMappingURL=useLoginHook.js.map

package/dist/template/axios/useLoginHook.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLoginHook.js","sourceRoot":"","sources":["../../../src/template/axios/useLoginHook.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,YAAY,GACvB,GAAG,EAAE,CAAC;;;;;;;;;;;;;;CAcP,CAAA"}

package/dist/template/axios/useLogoutHook.d.ts

@@ -0,0 +1,2 @@
+export declare const useLogoutHook: () => string;
+//# sourceMappingURL=useLogoutHook.d.ts.map

package/dist/template/axios/useLogoutHook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLogoutHook.d.ts","sourceRoot":"","sources":["../../../src/template/axios/useLogoutHook.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa,cAazB,CAAA"}

package/dist/template/axios/useLogoutHook.js

@@ -0,0 +1,15 @@
+export const useLogoutHook = () => `import { CommonErrorType } from "@/generated/api/@types/data-contracts"
+import { useMutation } from "@tanstack/react-query"
+import axios, { AxiosError } from "axios"
+
+export const useLogoutMutation = () => {
+  return useMutation<void, AxiosError<CommonErrorType>, void>({
+    mutationKey: ["AUTH_JWT_LOGOUT_CREATE"],
+    mutationFn: async () => {
+      const res = await axios.post("/api/auth/logout")
+      return res.data
+    },
+  })
+}
+`;
+//# sourceMappingURL=useLogoutHook.js.map

package/dist/template/axios/useLogoutHook.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLogoutHook.js","sourceRoot":"","sources":["../../../src/template/axios/useLogoutHook.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,aAAa,GAAG,GAAG,EAAE,CAAC;;;;;;;;;;;;;CAalC,CAAA"}

package/dist/template/axios/utilJwt.d.ts

@@ -0,0 +1,2 @@
+export declare const utilJwt: () => string;
+//# sourceMappingURL=utilJwt.d.ts.map

package/dist/template/axios/utilJwt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utilJwt.d.ts","sourceRoot":"","sources":["../../../src/template/axios/utilJwt.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,OAAO,cAkDnB,CAAA"}

package/dist/template/axios/utilJwt.js

@@ -0,0 +1,52 @@
+export const utilJwt = () => `import { cookies } from "next/headers"
+
+export const AUTH_ENDPOINTS = {
+  LOGIN: "/v1/user/login/", // TODO: Change to the actual login endpoint
+  REFRESH: "/v1/user/refresh/",
+}
+
+export const TOKEN_KEYS = {
+  ACCESS: "accessToken",
+  REFRESH: "refreshToken",
+} as const
+
+const cookieOptions = {
+  httpOnly: true,
+  secure: process.env.NODE_ENV === "production",
+  sameSite: process.env.NODE_ENV === "production" ? "lax" : "none",
+  path: "/",
+} as const
+
+export async function setTokens(accessToken: string, refreshToken?: string) {
+  const cookieStore = await cookies()
+
+  cookieStore.set(TOKEN_KEYS.ACCESS, accessToken, {
+    ...cookieOptions,
+    maxAge: 60 * 15, // 15min
+  })
+
+  if (refreshToken) {
+    cookieStore.set(TOKEN_KEYS.REFRESH, refreshToken, {
+      ...cookieOptions,
+      maxAge: 60 * 60 * 24 * 7, // 7days
+    })
+  }
+}
+
+export async function clearTokens() {
+  const cookieStore = await cookies()
+
+  cookieStore.delete(TOKEN_KEYS.ACCESS)
+  cookieStore.delete(TOKEN_KEYS.REFRESH)
+}
+
+export async function getTokens() {
+  const cookieStore = await cookies()
+
+  return {
+    accessToken: cookieStore.get(TOKEN_KEYS.ACCESS)?.value,
+    refreshToken: cookieStore.get(TOKEN_KEYS.REFRESH)?.value,
+  }
+}
+`;
+//# sourceMappingURL=utilJwt.js.map

package/dist/template/axios/utilJwt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utilJwt.js","sourceRoot":"","sources":["../../../src/template/axios/utilJwt.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,OAAO,GAAG,GAAG,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkD5B,CAAA"}

package/dist/template/supabase/actions/auth.d.ts

@@ -0,0 +1,2 @@
+export declare const supabaseAuthActions: (isNeedAuth: boolean) => string;
+//# sourceMappingURL=auth.d.ts.map

package/dist/template/supabase/actions/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../../../src/template/supabase/actions/auth.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,mBAAmB,GAAI,YAAY,OAAO,WA6DtD,CAAA"}

package/dist/template/supabase/actions/auth.js

@@ -0,0 +1,61 @@
+export const supabaseAuthActions = (isNeedAuth) => `"use server"
+
+${!isNeedAuth ? `import { ROUTES } from "@/generated/path/routes"` : 'import { ENV } from "@/configs/env"'}
+import { createClient } from "@/lib/supabase/server"
+import { redirect } from "next/navigation"
+
+export async function login(formData: FormData) {
+  const supabase = await createClient()
+  const email = formData.get("email") as string
+  const password = formData.get("password") as string
+
+  const { error } = await supabase.auth.signInWithPassword({
+    email,
+    password,
+  })
+
+  if (error) {
+    redirect(${isNeedAuth ? '"/login?message=login_failed"' : '"/"'})
+  }
+
+  redirect(${isNeedAuth ? '"/"' : "ROUTES.ADMIN"})
+}
+
+${isNeedAuth
+    ? `export async function signup(formData: FormData) {
+  const supabase = await createClient()
+  const email = formData.get("email") as string
+  const password = formData.get("password") as string
+
+  const { error } = await supabase.auth.signUp({
+    email,
+    password,
+  })
+
+  if (error) {
+    redirect("/login?message=signup_failed")
+  }
+
+  redirect("/login?message=signup_success")
+}
+
+export async function signInWithGoogle() {
+  const supabase = await createClient()
+  const { data, error } = await supabase.auth.signInWithOAuth({
+    provider: "google",
+    options: {
+      redirectTo: \`\${ENV.DOMAIN}/api/auth/google/callback\`,
+    },
+  })
+
+  if (error) {
+    redirect("/login?message=signin_with_failed&provider=google")
+  }
+
+  if (data.url) {
+    redirect(data.url)
+  }
+}`
+    : ""}
+`;
+//# sourceMappingURL=auth.js.map

package/dist/template/supabase/actions/auth.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.js","sourceRoot":"","sources":["../../../../src/template/supabase/actions/auth.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,UAAmB,EAAE,EAAE,CAAC;;EAE1D,CAAC,UAAU,CAAC,CAAC,CAAC,kDAAkD,CAAC,CAAC,CAAC,qCAAqC;;;;;;;;;;;;;;;eAe3F,UAAU,CAAC,CAAC,CAAC,+BAA+B,CAAC,CAAC,CAAC,KAAK;;;aAGtD,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,cAAc;;;EAI9C,UAAU;IACR,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiCJ;IACE,CAAC,CAAC,EACN;CACC,CAAA"}

package/dist/template/supabase/actions/crud.d.ts

@@ -0,0 +1,3 @@
+export declare const supabaseCrudService: (tableName: string) => string;
+export declare const supabaseCrudActions: (tableName: string) => string;
+//# sourceMappingURL=crud.d.ts.map

package/dist/template/supabase/actions/crud.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crud.d.ts","sourceRoot":"","sources":["../../../../src/template/supabase/actions/crud.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,mBAAmB,GAAI,WAAW,MAAM,WAsCpD,CAAA;AAED,eAAO,MAAM,mBAAmB,GAAI,WAAW,MAAM,WA8BpD,CAAA"}