@tatil/server-api 0.0.1

package/index.js

@@ -0,0 +1,4 @@
+export { default as Tatilsepeti } from './src/utils/tatilsepeti';
+export { default as TokenManager } from './src/utils/tokenManager';
+export { getNewToken } from './src/utils/auth';
+export { RequestLogger } from './src/utils/reklog';

package/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "@tatil/server-api",
+  "version": "0.0.1",
+  "description": "Tatilsepeti Server Api for Next.js server-side operations",
+  "main": "index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "axios": "^1.13.2",
+    "moment": "^2.29.4",
+    "reklog-request": "^0.0.22"
+  }
+}

package/src/utils/auth.js

@@ -0,0 +1,27 @@
+import { RequestLogger } from './reklog';
+
+const { API_URL, API_USERNAME, API_PASSWORD } = process.env;
+
+const logger = RequestLogger();
+
+export const getNewToken = async () => {
+  const options = {
+    method: 'POST',
+    body: `grant_type=password&username=${API_USERNAME}&password=${API_PASSWORD}`,
+    headers: {
+      Accept: 'application/json',
+      'Content-Type': 'application/x-www-form-urlencoded',
+    },
+  };
+
+  const body = {
+    grant_type: 'password',
+    username: API_USERNAME,
+    password: API_PASSWORD,
+  };
+
+  const req = await fetch(`${API_URL}/token`, options);
+  const { access_token, expires_in } = await req.json();
+
+  return { access_token, expires_in };
+};

package/src/utils/reklog.js

@@ -0,0 +1,11 @@
+import ReklogRequest from 'reklog-request';
+
+const { NODE_ENV, REKLOG_KEY } = process.env;
+
+export const RequestLogger = () => {
+  return ReklogRequest.init(REKLOG_KEY, {
+    environment: NODE_ENV,
+    debug: false,
+    excludeEndpoints: ['/content/headermenuv2'],
+  });
+};

package/src/utils/tatilsepeti.js

@@ -0,0 +1,172 @@
+import { cookies } from 'next/headers';
+import axios from 'axios';
+
+import TokenManager from './tokenManager';
+import { RequestLogger } from './reklog';
+
+const { API_URL } = process.env;
+
+class TatilsepetiApi {
+  constructor() {
+    this.baseURL = API_URL;
+    this.instance = axios.create({
+      baseURL: API_URL,
+    });
+    this.logger = RequestLogger();
+    this.defaultHeaders = {
+      'Content-Type': 'application/json',
+    };
+  }
+
+  joinEndpoint(endpoint) {
+    return endpoint.join('/');
+  }
+
+  fullEndpoint(endpoint) {
+    return `${this.baseURL}/api/v1/${this.joinEndpoint(endpoint)}`;
+  }
+
+  buildUrl(endpoint) {
+    if (Array.isArray(endpoint)) {
+      return this.fullEndpoint(endpoint);
+    }
+    return `${this.baseURL}/api/v1${endpoint}`;
+  }
+
+  getEndpointPath(endpoint) {
+    return Array.isArray(endpoint) ? this.joinEndpoint(endpoint) : endpoint;
+  }
+
+  setAuthCookies(accessToken, expiresAt) {
+    const response = new Response();
+    response.cookies.set('token', accessToken);
+    response.cookies.set('token_expire', expiresAt);
+  }
+
+  async getAuthHeaders() {
+    const cookieStore = await cookies();
+    const token = cookieStore.get('token');
+    const tokenExpire = cookieStore.get('token_expire');
+
+    const { token: newToken, tokenExpire: newExpire, refreshed } = await TokenManager.refreshTokenIfNeeded(
+      token?.value,
+      tokenExpire?.value
+    );
+
+    if (refreshed) {
+      this.setAuthCookies(newToken, newExpire);
+    }
+
+    return {
+      ...this.defaultHeaders,
+      Authorization: `Bearer ${newToken}`,
+    };
+  }
+
+  createResponse(data, status = 200) {
+    return new Response(
+      JSON.stringify({
+        status: 'success',
+        data,
+      }),
+      {
+        status,
+        headers: { ...this.defaultHeaders },
+      }
+    );
+  }
+
+  createErrorResponse(message, status = 500) {
+    return new Response(
+      JSON.stringify({
+        status: 'error',
+        message,
+      }),
+      {
+        status,
+        headers: { ...this.defaultHeaders },
+      }
+    );
+  }
+
+  async get(endpoint, params = {}) {
+    const endpointPath = this.getEndpointPath(endpoint);
+    const logId = this.logger.start(endpointPath, 'GET');
+    const url = this.buildUrl(endpoint);
+
+    const response = await this.instance.get(url, {
+      params,
+      headers: await this.getAuthHeaders(),
+    });
+
+    if (!response) {
+      this.logger.end(logId, {
+        statusCode: 500,
+        response: 'No response from server',
+        params,
+      });
+      return;
+    }
+
+    if (!response.data) {
+      this.logger.end(logId, {
+        statusCode: response.status || 500,
+        response: 'No data in response',
+        params,
+      });
+      return;
+    }
+
+    const { data } = response;
+
+    this.logger.end(logId, {
+      statusCode: response.status,
+      response: data,
+      params,
+    });
+
+    return data;
+  }
+
+  async post(endpoint, body = {}) {
+    const endpointPath = this.getEndpointPath(endpoint);
+    const logId = this.logger.start(endpointPath, 'POST');
+    const url = this.buildUrl(endpoint);
+
+    const response = await this.instance.post(url, body, {
+      headers: await this.getAuthHeaders(),
+    });
+
+    if (!response) {
+      this.logger.end(logId, {
+        statusCode: 500,
+        response: 'No response from server',
+        body,
+      });
+      return;
+    }
+
+    if (!response.data) {
+      this.logger.end(logId, {
+        statusCode: response.status || 500,
+        response: 'No data in response',
+        body,
+      });
+      return;
+    }
+
+    const { data } = response;
+
+    this.logger.end(logId, {
+      statusCode: response.status,
+      response: data,
+      body,
+    });
+
+    return data;
+  }
+}
+
+const Tatilsepeti = new TatilsepetiApi();
+
+export default Tatilsepeti;

package/src/utils/tokenManager.js

@@ -0,0 +1,41 @@
+import moment from 'moment';
+
+import { getNewToken } from './auth';
+
+class TokenManager {
+  isTokenExpired(token, tokenExpire) {
+    if (!token || !tokenExpire) {
+      return true;
+    }
+
+    const currentTime = moment().valueOf();
+    return currentTime >= Number(tokenExpire);
+  }
+
+  getExpirationTimestamp(expiresIn) {
+    return moment().add(Number(expiresIn), 'seconds').valueOf();
+  }
+
+  async refreshTokenIfNeeded(token, tokenExpire) {
+    if (!this.isTokenExpired(token, tokenExpire)) {
+      return {
+        token,
+        tokenExpire,
+        refreshed: false,
+      };
+    }
+
+    const { access_token: accessToken, expires_in: expiresIn } = await getNewToken();
+    const expiresAt = this.getExpirationTimestamp(expiresIn);
+
+    return {
+      token: accessToken,
+      tokenExpire: expiresAt,
+      refreshed: true,
+    };
+  }
+}
+
+const TokenManagerInstance = new TokenManager();
+
+export default TokenManagerInstance;