101 lines
2.5 KiB
TypeScript
Executable File
101 lines
2.5 KiB
TypeScript
Executable File
/// <reference types="bun-types" />
|
|
|
|
import { ServerContext, useServerRouter } from "./server-route";
|
|
|
|
export type SessionData<T extends Record<string, any> | undefined> = 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>;
|
|
};
|
|
|
|
type SessionServerHandler = {
|
|
cleanup: () => Promise<void>;
|
|
handle: (arg: ServerContext) => Promise<Response>;
|
|
};
|
|
|
|
export const createSessionServer = <T extends SessionData<any>>(arg: {
|
|
encrypt?: boolean;
|
|
router?: ReturnType<typeof useServerRouter>;
|
|
}): SessionServerHandler => {
|
|
const internal = {
|
|
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);
|
|
return new Response("fas");
|
|
// if (internal.has_router && internal.router) {
|
|
// return await internal.router.handle({
|
|
// ...server_arg,
|
|
// session: {
|
|
// ...server_session,
|
|
// current: undefined,
|
|
// },
|
|
// });
|
|
// }
|
|
|
|
// return handle(req);
|
|
},
|
|
};
|
|
|
|
return server_handler;
|
|
};
|