fix server session

server/server-route.ts

@@ -13,8 +13,7 @@ export type ServerContext = {
   };
 };
 
-export interface SessionContext<T extends SessionData<any>>
-  extends ServerContext {
+export interface SessionContext<T> extends ServerContext {
   session: ServerSession<T>;
 }
 
@@ -92,7 +91,10 @@ export const useServerRouter = <T extends ReturnType<typeof newServerRouter>>(
         if (route.opt && route.opt?.request_as === "raw") {
           result = await route.handler.default.bind(arg)();
         } else {
-          const params = await req.json();
+          let params = [];
+          try {
+            params = await req.json();
+          } catch (e) {}
           result = await route.handler.default.bind(arg)(...params);
         }
 

server/server-session.ts

@@ -8,7 +8,7 @@ import {
   SingleSession,
 } from "./session/session-store";
 
-export type ServerSession<T extends SessionData<any>> = SessionStore<T> & {
+export type ServerSession<T> = SessionStore<T> & {
   current?: SingleSession<T>;
 };
 
@@ -17,11 +17,12 @@ type SessionServerHandler = {
   handle: (arg: ServerContext) => Promise<Response>;
 };
 
-export const createSessionServer = <T extends SessionData<any>>(arg: {
+export const createSessionServer = <T >(arg: {
   encrypt?: boolean;
   router?: ReturnType<typeof useServerRouter>;
+  site_id?: string;
 }): SessionServerHandler => {
-  const server_session = newSessionStore<T>();
+  const server_session = newSessionStore<T>(arg.site_id);
 
   const server_handler: SessionServerHandler = {
     async cleanup() {},

server/session/schema.ts

@@ -5,15 +5,16 @@ import { select } from "lib/preset/login/utils/select";
 export const session = sqliteTable(
   "session",
   {
-    session_id: text("session_id")
+    sid: text("sid")
       .notNull()
       .primaryKey()
       .$defaultFn(() => createId()),
+    uid: text("uid").notNull(),
     created_at: integer("created_at", { mode: "timestamp_ms" }).default(
       new Date()
     ),
     active: integer("active", { mode: "boolean" }),
-    data: text("data", { mode: "json" }),
+    data: text("data", { mode: "json" }).notNull(),
     expired_at: integer("expired_at", { mode: "timestamp_ms" }),
   },
   (table) => {
@@ -26,7 +27,7 @@ export const session = sqliteTable(
 export const track = sqliteTable(
   "track",
   {
-    track_id: text("track_id")
+    id: text("id")
       .notNull()
       .primaryKey()
       .$defaultFn(() => createId()),

server/session/session-store.ts

@@ -1,57 +1,153 @@
-export type NewSessionData<T extends Record<string, any>> = T & {
+/// <reference types="bun-types" />
+import Database from "bun:sqlite";
+import { dir } from "../utils/dir";
+import { mkdirSync } from "fs";
+import { join } from "path";
+import { BunSQLiteDatabase, drizzle } from "drizzle-orm/bun-sqlite";
+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 type SessionData<T extends Record<string, any>> = NewSessionData<T> & {
+export interface SessionData<T> extends NewSessionData<T> {
   sid: string;
+  active: boolean;
   created_at: number;
-};
+}
 
-export type SingleSession<T extends SessionData<any>> = {
-  data: T;
-  track: (arg: { path: string }) => Promise<void>;
-  destroy: () => Promise<void>;
-};
+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 extends SessionData<any>> = {
-  create: (
-    data: Record<string, any> & {
+export type SessionStore<T> = {
+  create: (arg: {
     uid: string;
     role: string;
+    data?: T;
     expired_at?: number;
-    }
-  ) => Promise<SingleSession<T>>;
-  findMany: (arg: Partial<FilterSessionArg>) => Promise<SingleSession<T>[]>;
-  findFirst: (
-    arg: Partial<FilterSessionArg>
-  ) => Promise<null | SingleSession<T>>;
+  }) => SingleSession<T>;
+  findMany: (arg?: Partial<FilterSessionArg>) => SingleSession<T>[];
+  findFirst: (arg?: Partial<FilterSessionArg>) => 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) {},
+export const newSessionStore = <T>(site_id?: string) => {
+  const db_path = site_id
+    ? dir.data(`/code/${site_id}/site/sqlite`)
+    : dir.data(`/sqlite`);
+
+  mkdirSync(db_path, { recursive: true });
+
+  const path = { session: join(db_path, "session.db") };
+  const db = {
+    session: drizzle(new Database(path.session), { schema: { session } }),
+    track: {} as Record<string, BunSQLiteDatabase<Record<string, never>>>,
   };
-      return new_session;
+
+  db.session.run(sql`
+CREATE TABLE IF NOT EXISTS session (
+	sid text PRIMARY KEY NOT NULL,
+	uid text NOT NULL,
+	created_at integer NOT NULL DEFAULT current_timestamp,
+	active integer,
+	data text NOT NULL,
+	expired_at integer
+);
+CREATE INDEX IF NOT EXISTS expired_at_idx ON session (expired_at);
+  `);
+
+  //   const track_ddl = sql`
+  // CREATE TABLE track (
+  // 	id text PRIMARY KEY NOT NULL,
+  // 	created_at integer DEFAULT current_timestamp,
+  // 	session_id text,
+  // 	url text NOT NULL,
+  // 	referer text,
+  // 	user_ip text,
+  // 	data text,
+  // 	tstamp integer DEFAULT current_timestamp
+  // );
+  // CREATE INDEX session_id ON track (session_id);`;
+
+  const createSingleStore = <E extends SessionData<T>>(data: any) => {
+    if (!data) return null;
+
+    const row: SingleSession<E> = {
+      ...data,
+      destroy() {
+        try {
+          db.session.delete(session).where(eq(session.sid, row.sid)).run();
+          return true;
+        } catch (e) {
+          console.error(e);
+          return false;
+        }
       },
-    async findFirst(arg) {
-      return null;
+      track(arg) {},
+    };
+
+    return row;
+  };
+
+  return {
+    create(data) {
+      return createSingleStore(
+        db.session
+          .insert(session)
+          .values({
+            uid: data.uid,
+            data,
+            active: true,
+            expired_at: data.expired_at
+              ? new Date(data.expired_at * 1000)
+              : undefined,
+          })
+          .returning()
+          .get()
+      );
     },
-    async findMany(arg) {
-      return [];
+    findFirst(arg) {
+      return createSingleStore(
+        db.session
+          .select()
+          .from(session)
+          .where(
+            and(
+              ...Object.entries(arg || {}).map(([k, v]) => {
+                return eq((session as any)[k], v);
+              })
+            )
+          )
+          .get()
+      );
+    },
+    findMany(arg) {
+      return db.session
+        .select()
+        .from(session)
+        .where(
+          and(
+            ...Object.entries(arg || {}).map(([k, v]) => {
+              return eq((session as any)[k], v);
+            })
+          )
+        )
+        .all()
+        .map((e) => createSingleStore(e));
     },
   } as SessionStore<T>;
 };

server/utils/dir.ts

@@ -0,0 +1,17 @@
+import { join } from "path";
+
+const g = (typeof global !== "undefined" ? global : undefined) as unknown as {
+  datadir?: string;
+  mode?: string;
+};
+
+export const dir = {
+  data: (path: string) => {
+    const final_path = path
+      .split("/")
+      .filter((e) => e !== "..")
+      .join("/");
+    if (g.mode === "prod") return join(process.cwd(), "..", "data", final_path);
+    else return join(process.cwd(), "data", final_path);
+  },
+};