oak to hono

Author: GroophyLifefor

.gitignore

@@ -2,6 +2,7 @@
 
 # vscode
 /.vscode
+dev.md
 
 # dependencies
 /node_modules

api/Users/getUserInfo.ts

@@ -0,0 +1,52 @@
+import {
+  type Ctx,
+  ValidationType,
+} from '@/endpoints.ts';
+import { z } from 'npm:zod';
+import { shouldBeUserId } from '@/lib/userIdCheck.ts';
+import { OptionalIUser } from '@/db/models/Users.ts';
+
+/**
+ * GET /api/getUserInfo
+ *
+ * What do: Log the user's log
+ */
+export async function GET(ctx: Ctx) {
+  const requestData = ctx.get('dataValidation').user
+  const query: QueryType = requestData.query;
+
+  // middleware converts userId to User
+  const targetUser = query.userId;
+
+  const userData: OptionalIUser = {
+    registerType: targetUser.registerType,
+    registerDate: targetUser.registerDate,
+    lastLoginDate: targetUser.lastLoginDate,
+    email: targetUser.email,
+    name: targetUser.name,
+    username: targetUser.username,
+    picture: targetUser.picture,
+    ...targetUser.socialMedias?.reduce(
+      (
+        acc: Record<string, string>,
+        { key, value }: { key: string; value: string }
+      ) => ({ ...acc, [key]: value }),
+      {}
+    ),
+  };
+
+  ctx.status(200);
+  return await ctx.json(userData);
+}
+
+// Configurations
+export const path = '/api/getUserInfo';
+export const validation: ValidationType = {
+  query: {
+    userId: shouldBeUserId,
+  },
+};
+export const middlewares = ['auth:validToken'];
+
+const querySchema = z.object(validation.query as z.ZodRawShape);
+type QueryType = z.infer<typeof querySchema>;

api/Users/whoAmI.ts

@@ -1,36 +1,10 @@
 import {
-  type ctx,
-  type MiddlewareDataArray,
-  getDataFromMiddleware,
-  SetResponse,
-  ValidationType
+  type Ctx,
 } from '@/endpoints.ts';
 import { IUser, OptionalIUser } from '@/db/models/Users.ts';
-import {z} from 'npm:zod';
 
-
-
-export const pattern = new URLPattern({ pathname: '/api/whoAmI' });
-export const validation: ValidationType = {
-  // /api/whoAmI?test=anystring
-  query: {
-    test: z.string().min(4),
-  },
-
-  // /api/whoAmI
-  // {
-  //   test: 'anystring'
-  // }
-  body: z.object({
-    test: z.string().optional(),
-  }),
-}
-export const middlewares = [
-  'auth:validToken',
-];
-
-export function GET(ctx: ctx, _middlewareDatas: MiddlewareDataArray): void {
-  const data = getDataFromMiddleware(_middlewareDatas, 'auth:validToken');
+export function GET(ctx: Ctx) {
+  const data = ctx.get('auth:validToken').user;
   const user = data.user as IUser;
 
   const userData: OptionalIUser = {
@@ -41,14 +15,18 @@ export function GET(ctx: ctx, _middlewareDatas: MiddlewareDataArray): void {
     name: user.name,
     username: user.username,
     picture: user.picture,
+    ...user.socialMedias?.reduce(
+      (
+        acc: Record<string, string>,
+        { key, value }: { key: string; value: string }
+      ) => ({ ...acc, [key]: value }),
+      {}
+    ),
   };
 
-  user.socialMedias?.forEach((socialMedia) => {
-    userData[socialMedia.key] = socialMedia.value;
-  });
-
-  return SetResponse(ctx, {
-    status: 200,
-    body: userData,
-  });
+  ctx.status(200);
+  return ctx.json(userData);
 }
+
+export const path = '/api/whoAmI';
+export const middlewares = ['auth:validToken'];

api/noCommentTemplate.ts

@@ -0,0 +1,40 @@
+import {
+  type ctx,
+  type MiddlewareDataArray,
+  getDataFromMiddleware,
+  SetResponse,
+  ValidationType,
+} from '@/endpoints.ts';
+import { z } from 'npm:zod';
+
+/**
+ * POST /api/log
+ * 
+ * What do: Log the user's log 
+ */
+export function POST(ctx: ctx, _middlewareDatas: MiddlewareDataArray): void {
+  const requestData = getDataFromMiddleware(
+    _middlewareDatas,
+    'dataValidation'
+  ).user;
+  const body: BodyType = requestData.body;
+
+  console.log('new log', body.log);
+
+  return SetResponse(ctx, {
+    status: 200,
+    body: {},
+  });
+}
+
+// Configurations
+export const pattern = new URLPattern({ pathname: '/api/log' });
+export const validation: ValidationType = {
+  query: {},
+  body: z.object({
+    log: z.string().min(1),
+  }),
+};
+export const middlewares = ['auth:validToken'];
+
+type BodyType = z.infer<typeof validation.body>;

api/template.ts

@@ -0,0 +1,97 @@
+import {
+  type ctx,
+  type MiddlewareDataArray,
+  getDataFromMiddleware,
+  SetResponse,
+  ValidationType,
+} from '@/endpoints.ts';
+import { IUser } from '@/db/models/Users.ts';
+import { z } from 'npm:zod';
+
+/**
+ * STEP 1: (OPTIONAL) Do this setting on
+ * If you using VSCode, enable 'editor.foldingImportsByDefault' to fold imports
+ * and get better DX.
+ */
+
+/**
+ * STEP 2: (REQUIRED) Endpoint path implementation
+ * Don't forget to add filepath to endpoints.ts's loadEndpoints function's return array.
+ * Because Deno Deploy don't allow dynamic imports cause of security reasons.
+ */
+
+/**
+ * STEP 3: (REQUIRED) Readability
+ * Don't want create a new file? Create it! Readability is most important thing.
+ * Split to multiple files if you need. Single Responsibility Principle is base rule.
+ */
+
+/**
+ * POST /api/postEvent
+ *
+ * What do: Post the event
+ */
+export function POST(ctx: ctx, _middlewareDatas: MiddlewareDataArray): void {
+  // .user means user so developer level which not base(library) level
+  const authData = getDataFromMiddleware(
+    _middlewareDatas,
+    'auth:validToken'
+  ).user;
+  const user = authData as IUser;
+
+  const requestData = getDataFromMiddleware(
+    _middlewareDatas,
+    'dataValidation'
+  ).user;
+  const query: QueryType = requestData.query;
+  const body: BodyType = requestData.body;
+
+  console.log('logging', query.eventId);
+  console.log('Another logging', body.name);
+
+  return SetResponse(ctx, {
+    status: 200,
+    body: {
+      username: user.username,
+    },
+  });
+}
+
+/**
+ * GET /api/postEvent
+ *
+ * What do: Get the event
+ */
+export function GET(ctx: ctx, _middlewareDatas: MiddlewareDataArray): void {
+  return SetResponse(ctx, {
+    status: 200,
+    body: {},
+  });
+  // ...
+}
+
+// Configurations
+export const pattern = new URLPattern({ pathname: '/api/postEvent' });
+export const validation: ValidationType = {
+  // Please use for 'GET', 'DELETE', 'OPTIONS' or 'HEAD'
+  // /api/postEvent?test=anystring
+  query: {
+    eventId: z.string().min(4),
+  },
+
+  // Please use for 'POST', 'PUT' or 'PATCH'
+  // /api/postEvent
+  // {
+  //   name: 'anystring',
+  //   description: 'anystring',
+  // }
+  body: z.object({
+    name: z.string().min(5),
+    description: z.string().min(1),
+  }),
+};
+export const middlewares = ['auth:validToken'];
+
+const querySchema = z.object(validation.query as z.ZodRawShape);
+type QueryType = z.infer<typeof querySchema>;
+type BodyType = z.infer<typeof validation.body>;

db/models/Users.ts

@@ -1,4 +1,6 @@
 import mongoose, { Document, Model } from 'npm:mongoose';
+import { Ctx } from '@/endpoints.ts';
+import { addBulletToLastTrace } from '@/lib/requestTracer.ts';
 
 export interface IUser extends Document {
   registerType: string;
@@ -96,9 +98,44 @@ const getUserIdByToken = async (token: string): Promise<string | null> => {
  * @param {string} uid - The user ID to check
  * @returns {Promise<IUser | null>} - The user object or null if not found
  */
-const getUserById = async (uid: string): Promise<IUser | null> => {
+const getUserById = async (
+  ctx: Ctx | null,
+  uid: string
+): Promise<IUser | null> => {
+  const startMS = Date.now();
   const user = await User.findOne({ uid });
+  const duration = Date.now() - startMS;
+  if (ctx) {
+    addBulletToLastTrace(
+      ctx,
+      `db_query:findUserByUserID - duration: ${duration}ms`
+    );
+  }
   return user;
 };
 
-export { User, isUserRegistered, getUserIdByToken, getUserById };
+const getUserByToken = async (
+  ctx: Ctx | null,
+  token: string
+): Promise<IUser | null> => {
+  const startMS = Date.now();
+  const user = await User.findOne({
+    token,
+  });
+  const duration = Date.now() - startMS;
+  if (ctx) {
+    addBulletToLastTrace(
+      ctx,
+      `db_query:findUserByToken - duration: ${duration}ms`
+    );
+  }
+  return user;
+};
+
+export {
+  User,
+  isUserRegistered,
+  getUserIdByToken,
+  getUserById,
+  getUserByToken,
+};

db/models/image.ts

@@ -1,5 +1,6 @@
 import mongoose, { Document, Model } from 'npm:mongoose';
 
+
 interface IImage extends Document {
   uid: string;
   owner_uid: string;

db/mongodb.ts

@@ -1,8 +1,10 @@
 import mongoose from 'npm:mongoose';
 import { config } from 'https://deno.land/x/[email protected]/mod.ts';
-import { Middleware } from 'https://deno.land/x/[email protected]/middleware.ts';
-import process from "node:process";
-import { loop } from "@/lib/loop.ts";
+import process from 'node:process';
+import { loop } from '@/lib/loop.ts';
+import { Ctx } from '@/endpoints.ts';
+import { type StatusCode } from 'npm:hono/utils/http-status';
+import { endTrace, startTrace } from "@/lib/requestTracer.ts";
 
 config({ export: true, path: '.env.local' });
 
@@ -26,11 +28,13 @@ async function connect() {
 
   state = 'connecting';
   // console.log('Connecting to MongoDB...');
-  startTime = Date.now();
+  if (!startTime) {
+    startTime = Date.now();
+  }
   client;
 
   try {
-    client = await mongoose.connect((MONGODB_URL as string) || '')
+    client = await mongoose.connect((MONGODB_URL as string) || '');
   } catch (err) {
     state = 'failed';
     stop();
@@ -59,7 +63,8 @@ async function connect() {
 
 type DBState = 'not-started' | 'connecting' | 'failed' | 'connected';
 
-const stateMiddleware: Middleware = (ctx, next) => {
+const dbStateMiddleware = async (ctx: Ctx, next: () => void) => {
+  startTrace(ctx, 'Database state middleware');
   const DB_Responses: Record<DBState, { body: string; status: number }> = {
     'not-started': {
       body: 'Database connection not started',
@@ -84,12 +89,13 @@ const stateMiddleware: Middleware = (ctx, next) => {
   };
 
   if (state !== 'connected') {
-    ctx.response.status = DB_Responses[state as DBState].status;
-    ctx.response.body = DB_Responses[state as DBState].body;
-    return;
+    ctx.status(DB_Responses[state as DBState].status as StatusCode);
+    endTrace(ctx, 'Database state middleware');
+    return await ctx.body(DB_Responses[state as DBState].body);;
   }
 
-  return next();
+  endTrace(ctx, 'Database state middleware');
+  return await next();
 };
 
-export { client as default, connect, stateMiddleware };
+export { client as default, connect, dbStateMiddleware };