fix

server/server-route.ts

@@ -86,13 +86,13 @@ export const useServerRouter = <T extends ReturnType<typeof newServerRouter>>(
         if (route.handler instanceof Promise) {
           route.handler = await route.handler;
         }
-
+        
         let result = null;
         if (!route.opt || route.opt?.request_as === "raw") {
-          result = await route.handler.default();
+          result = await route.handler.default.bind(arg)();
         } else {
           const params = await req.json();
-          result = await route.handler.default(...params);
+          result = await route.handler.default.bind(arg)(...params);
         }
 
         if (typeof result === "object" && result instanceof Response) {

server/server-session.ts

@@ -1,40 +1,14 @@
 /// <reference types="bun-types" />
 
 import { ServerContext, useServerRouter } from "./server-route";
+import {
+  newSessionStore,
+  SessionData,
+  SessionStore,
+  SingleSession,
+} from "./session/session-store";
 
-export type SessionData<T extends Record<string, any> | undefined> = T & {
+export type ServerSession<T extends SessionData<any>> = SessionStore<T> & {
-  uid: string;
-  role: string;
-  sid: string;
-  expired_at?: number;
-  created_at: number;
-};
-
-export type SingleSession<T extends SessionData<any>> = {
-  data: T;
-  track: (arg: { path: string }) => Promise<void>;
-  destroy: () => Promise<void>;
-};
-
-type FilterSessionArg = {
-  uid: string;
-  sid: string;
-  role: string;
-  created_at: { gt?: number; lt?: number };
-  expired_at: { gt?: number; lt?: number };
-};
-export type ServerSession<T extends SessionData<any>> = {
-  create: (
-    data: Record<string, any> & {
-      uid: string;
-      role: string;
-      expired_at?: number;
-    }
-  ) => Promise<SingleSession<T>>;
-  findMany: (arg: Partial<FilterSessionArg>) => Promise<SingleSession<T>[]>;
-  findFirst: (
-    arg: Partial<FilterSessionArg>
-  ) => Promise<null | SingleSession<T>>;
   current?: SingleSession<T>;
 };
 
@@ -47,52 +21,24 @@ export const createSessionServer = <T extends SessionData<any>>(arg: {
   encrypt?: boolean;
   router?: ReturnType<typeof useServerRouter>;
 }): SessionServerHandler => {
-  const internal = {
+  const server_session = newSessionStore<T>();
-    has_router: false,
-    router: null as null | ReturnType<typeof useServerRouter>,
-  };
-  const server_session: Omit<ServerSession<T>, "current"> = {
-    async create(data) {
-      const new_session: SingleSession<T> = {
-        data: { ...data, created_at: Date.now() } as T,
-        async destroy() {},
-        async track(arg) {},
-      };
-      return new_session;
-    },
-    async findFirst(arg) {
-      return null;
-    },
-    async findMany(arg) {
-      return [];
-    },
-  };
-
-  if (typeof arg.router === "object" && arg.router instanceof Promise) {
-    internal.has_router = true;
-    arg.router.then((e) => {
-      internal.router = e;
-    });
-  }
 
   const server_handler: SessionServerHandler = {
     async cleanup() {},
     async handle(server_arg) {
       const { req, handle } = server_arg;
 
-      console.log("makaru", internal.has_router, internal.router);
+      if (arg.router) {
-      return new Response("fas");
+        return await arg.router.handle({
-      // if (internal.has_router && internal.router) {
+          ...server_arg,
-      //   return await internal.router.handle({
+          session: {
-      //     ...server_arg,
+            ...server_session,
-      //     session: {
+            current: undefined,
-      //       ...server_session,
+          },
-      //       current: undefined,
+        });
-      //     },
+      }
-      //   });
-      // }
 
-      // return handle(req);
+      return handle(req);
     },
   };
 

server/session/session-store.ts

@@ -0,0 +1,57 @@
+export type NewSessionData<T extends Record<string, any>> = T & {
+  uid: string;
+  role: string;
+  expired_at?: number;
+};
+
+export type SessionData<T extends Record<string, any>> = NewSessionData<T> & {
+  sid: string;
+  created_at: number;
+};
+
+export type SingleSession<T extends SessionData<any>> = {
+  data: T;
+  track: (arg: { path: string }) => Promise<void>;
+  destroy: () => Promise<void>;
+};
+
+type FilterSessionArg = {
+  uid: string;
+  sid: string;
+  role: string;
+  created_at: { gt?: number; lt?: number };
+  expired_at: { gt?: number; lt?: number };
+};
+
+export type SessionStore<T extends SessionData<any>> = {
+  create: (
+    data: Record<string, any> & {
+      uid: string;
+      role: string;
+      expired_at?: number;
+    }
+  ) => Promise<SingleSession<T>>;
+  findMany: (arg: Partial<FilterSessionArg>) => Promise<SingleSession<T>[]>;
+  findFirst: (
+    arg: Partial<FilterSessionArg>
+  ) => Promise<null | SingleSession<T>>;
+};
+
+export const newSessionStore = <T>() => {
+  return {
+    async create(data) {
+      const new_session: SingleSession<T> = {
+        data: { ...data, created_at: Date.now() } as T,
+        async destroy() {},
+        async track(arg) {},
+      };
+      return new_session;
+    },
+    async findFirst(arg) {
+      return null;
+    },
+    async findMany(arg) {
+      return [];
+    },
+  } as SessionStore<T>;
+};