fix

server/context.ts

@@ -0,0 +1,9 @@
+import { ServerContext, SessionContext } from "./server-route";
+
+export const sessionContext = <T>(sf: any) => {
+  return sf as unknown as SessionContext<T>;
+};
+
+export const serverContext = (sf: any) => {
+  return sf as unknown as ServerContext;
+};

server/server-route.ts

@@ -1,7 +1,7 @@
 import { _post } from "lib/utils/post";
 import { addRoute, createRouter, findRoute } from "rou3";
-import { ServerSession } from "./server-session";
+import { ServerSession } from "./session/server-session";
-import { SessionData } from "./session/session-store";
+import { SessionData } from "./session/store/session-store";
 
 export type ServerContext = {
   req: Request;
@@ -104,7 +104,6 @@ export const useServerRouter = <T extends ReturnType<typeof newServerRouter>>(
 
         return new Response(JSON.stringify(result));
       }
-      return await arg.handle(arg.req);
     },
   };
 };

server/server-session.ts

@@ -1,47 +0,0 @@
-/// <reference types="bun-types" />
-
-import { ServerContext, useServerRouter } from "./server-route";
-import {
-  newSessionStore,
-  SessionData,
-  SessionStore,
-  SingleSession,
-} from "./session/session-store";
-
-export type ServerSession<T> = SessionStore<T> & {
-  current?: SingleSession<T>;
-};
-
-type SessionServerHandler = {
-  cleanup: () => Promise<void>;
-  handle: (arg: ServerContext) => Promise<Response>;
-};
-
-export const createSessionServer = <T >(arg: {
-  encrypt?: boolean;
-  router?: ReturnType<typeof useServerRouter>;
-  site_id?: string;
-}): SessionServerHandler => {
-  const server_session = newSessionStore<T>(arg.site_id);
-
-  const server_handler: SessionServerHandler = {
-    async cleanup() {},
-    async handle(server_arg) {
-      const { req, handle } = server_arg;
-
-      if (arg.router) {
-        return await arg.router.handle({
-          ...server_arg,
-          session: {
-            ...server_session,
-            current: undefined,
-          },
-        });
-      }
-
-      return handle(req);
-    },
-  };
-
-  return server_handler;
-};

server/session/client-session.ts

@@ -0,0 +1,43 @@
+import { newClientRouter } from "../server-route";
+import { sessionRouter } from "./router/session-router";
+import { sessionClientStore } from "./store/client-store";
+import { ClientSession } from "./type";
+
+export const newClientSession = <T>(arg?: {
+  on: Partial<{
+    session: ClientSession<T>;
+    messageReceived: () => Promise<void>;
+    afterLogin: () => Promise<void>;
+    afterLogout: () => Promise<void>;
+    afterRecheck: () => Promise<void>;
+  }>;
+}) => {
+  const store = sessionClientStore<T>();
+  const client = newClientRouter(sessionRouter);
+
+  const session: ClientSession<T> = {
+    status: "checking",
+    current: null,
+    async recheck() {
+      const current = await store.load();
+      if (!current) {
+        this.status = "guest";
+      } else {
+        this.status = await client.check(current.uid, current.sid);
+      }
+      return { status: this.status };
+    },
+    async login(arg: {
+      method: "user-pass";
+      username: string;
+      password: string;
+    }) {},
+    async logout() {},
+  };
+
+  session.recheck().then((e) => {
+    console.log(e);
+  });
+
+  return session;
+};

server/session/router/session-check.ts

@@ -0,0 +1,11 @@
+import { EsensiSession } from "app/server/session";
+import { sessionContext } from "lib/server/context";
+import { ClientSessionStatus } from "../type";
+
+export default async function (this: any, uid: string, sid: string) {
+  const ctx = sessionContext<EsensiSession>(this);
+
+  let result = "invalid" as ClientSessionStatus;
+
+  return result;
+}

server/session/router/session-router.ts

@@ -0,0 +1,5 @@
+import { newServerRouter } from "lib/server/server-route";
+
+export const sessionRouter = newServerRouter({
+  check: ["/_session/check", () => import("./session-check")],
+});

server/session/server-session.ts

@@ -0,0 +1,49 @@
+/// <reference types="bun-types" />
+
+import { ServerContext, useServerRouter } from "../server-route";
+import { sessionRouter } from "./router/session-router";
+import { newSessionStore } from "./store/session-store";
+
+type SessionServerHandler = {
+  cleanup: () => Promise<void>;
+  handle: (arg: ServerContext) => Promise<Response>;
+};
+
+export const createSessionServer = <T>(arg: {
+  encrypt?: boolean;
+  server_router?: ReturnType<typeof useServerRouter>;
+  site_id?: string;
+}): SessionServerHandler => {
+  const session_store = newSessionStore<T>(arg.site_id);
+
+  const session_router = useServerRouter(sessionRouter);
+
+  const server_handler: SessionServerHandler = {
+    async cleanup() {},
+    async handle(server_arg) {
+      const { req, handle, url } = server_arg;
+
+      const route_arg = {
+        ...server_arg,
+        session: {
+          ...session_store,
+          current: undefined,
+        },
+      };
+
+      if (url.pathname.startsWith("/_session/")) {
+        const res = await session_router.handle(route_arg);
+        if (res) return res;
+      }
+
+      if (arg.server_router) {
+        const res = await arg.server_router.handle(route_arg);
+        if (res) return res;
+      }
+
+      return handle(req);
+    },
+  };
+
+  return server_handler;
+};

server/session/store/client-store.ts

@@ -0,0 +1,15 @@
+import { SessionData } from "../type";
+
+const w = window as unknown as { _prasi?: { site_id?: string } };
+
+export const sessionClientStore = <T>() => ({
+  async load(): Promise<null | SessionData<T>> {
+    if (w._prasi?.site_id) {
+      const cur = localStorage.getItem(`sid-${w._prasi?.site_id}`);
+      try {
+        return JSON.parse(cur || "");
+      } catch (e) {}
+    }
+    return null;
+  },
+});

server/session/store/schema.ts

@@ -1,6 +1,5 @@
 import { createId } from "@paralleldrive/cuid2";
 import { index, integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
-import { select } from "lib/preset/login/utils/select";
 
 export const session = sqliteTable(
   "session",

server/session/store/session-store.ts

@@ -1,49 +1,12 @@
 /// <reference types="bun-types" />
 import Database from "bun:sqlite";
-import { dir } from "../utils/dir";
+import { and, eq, sql } from "drizzle-orm";
+import { BunSQLiteDatabase, drizzle } from "drizzle-orm/bun-sqlite";
 import { mkdirSync } from "fs";
 import { join } from "path";
-import { BunSQLiteDatabase, drizzle } from "drizzle-orm/bun-sqlite";
+import { dir } from "../../utils/dir";
+import { SessionData, SessionStore, SingleSession } from "../type";
 import { session } from "./schema";
-import { and, eq, sql } from "drizzle-orm";
-
-export interface NewSessionData<T> {
-  uid: string;
-  role: string;
-  data?: T;
-  expired_at?: number;
-}
-
-export interface SessionData<T> extends NewSessionData<T> {
-  sid: string;
-  active: boolean;
-  created_at: number;
-}
-
-export interface SingleSession<T> extends SessionData<T> {
-  track: (arg: { path: string }) => void;
-  destroy: () => boolean;
-}
-
-type FilterSessionArg = {
-  uid: string;
-  sid: string;
-  role: string;
-  active: boolean;
-  created_at: { gt?: number; lt?: number };
-  expired_at: { gt?: number; lt?: number };
-};
-
-export type SessionStore<T> = {
-  create: (arg: {
-    uid: string;
-    role: string;
-    data?: T;
-    expired_at?: number;
-  }) => SingleSession<T>;
-  findMany: (arg?: Partial<FilterSessionArg>) => SingleSession<T>[];
-  findFirst: (arg?: Partial<FilterSessionArg>) => null | SingleSession<T>;
-};
 
 export const newSessionStore = <T>(site_id?: string) => {
   const db_path = site_id

server/session/type.ts

@@ -0,0 +1,54 @@
+export interface NewSessionData<T> {
+  uid: string;
+  role: string;
+  data?: T;
+  expired_at?: number;
+}
+
+export interface SessionData<T> extends NewSessionData<T> {
+  sid: string;
+  active: boolean;
+  created_at: number;
+}
+
+export interface SingleSession<T> extends SessionData<T> {
+  track: (arg: { path: string }) => void;
+  destroy: () => boolean;
+}
+
+type FilterSessionArg = {
+  uid: string;
+  sid: string;
+  role: string;
+  active: boolean;
+  created_at: { gt?: number; lt?: number };
+  expired_at: { gt?: number; lt?: number };
+};
+
+export type SessionStore<T> = {
+  create: (arg: {
+    uid: string;
+    role: string;
+    data?: T;
+    expired_at?: number;
+  }) => SingleSession<T>;
+  findMany: (arg?: Partial<FilterSessionArg>) => SingleSession<T>[];
+  findFirst: (arg?: Partial<FilterSessionArg>) => null | SingleSession<T>;
+};
+
+export type ServerSession<T> = SessionStore<T> & {
+  current?: SingleSession<T>;
+};
+
+export type ClientSessionStatus = "checking" | "guest" | "expired" | "active";
+export type ClientSession<T> = {
+  status: ClientSessionStatus;
+  current: null | SessionData<T>;
+  recheck(): Promise<{ status: ClientSessionStatus }>;
+  login(arg: {
+    method: "user-pass";
+    username: string;
+    password: string;
+  }): Promise<void>;
+  logout(): Promise<void>;
+};

utils/client-session.ts

@@ -1,4 +1,4 @@
-import { SessionData } from "lib/server/server-session";
+import { SessionData } from "lib/server/session/server-session";
 
 const w = window as unknown as {
   _prasi_session: any;