TypeScript

session.ts

// deno-lint-ignore-file ban-ts-comment
import { Cookie, getCookies, setCookie } from "https://deno.land/std/http/mod.ts";

type Primitive = string | boolean | number | bigint | null;
type Primitives = Primitive | Record<string, Primitive> | Primitive[];
type PrimitivesRecord = { [x: string]: Primitives };

// deno-lint-ignore no-explicit-any
type TAny = any;
type BaseSession<
  Data extends PrimitivesRecord,
  FlashMessage extends PrimitivesRecord,
> = {
  get destroyed(): boolean;
  get sessionId(): string;
  get data(): Map<string, Data>;
  flash<
    K extends keyof FlashMessage | string,
    V extends K extends undefined ? TAny : FlashMessage[K] | undefined =
      // @ts-expect-error
      undefined,
  >(
    key: K,
    value?: V,
  ): V extends undefined ? (K extends undefined ? TAny : FlashMessage[K])
    : void;
  destroy(): void;
};

export type Session<
  Data extends PrimitivesRecord,
  FlashMessage extends PrimitivesRecord,
> =
  & BaseSession<Data, FlashMessage>
  & { [K in keyof Data]: K extends undefined ? TAny : Data[K] };

export interface SessionStorage {
  get sessionId(): string;
  get data(): Map<string, TAny>;
  write(newData: Map<string, TAny>): Promise<void>;
  destroy(): Promise<void>;
}

export type CreateSessionStorageFn = (
  cid: string | undefined,
) => Promise<SessionStorage>;
type Options = {
  cookieName?: string;
  cookieOptions?: Omit<Cookie, "name" | "value" | "unparsed">;
  createStorage?: CreateSessionStorageFn;
  secret?: string;
};

interface SessionFactory {
  getSession<
    Data extends PrimitivesRecord = PrimitivesRecord,
    FlashMessage extends PrimitivesRecord = PrimitivesRecord,
  >(req: Request): Promise<Session<Data, FlashMessage>>;
  commitSession<
    Data extends PrimitivesRecord = PrimitivesRecord,
    FlashMessage extends PrimitivesRecord = PrimitivesRecord,
  >(
    res: Response,
    session: Session<Data, FlashMessage>,
  ): Promise<Response>;
}

const genId = () => crypto.randomUUID();
export function createMemoryStorage(): CreateSessionStorageFn {
  const store = new Map<string, Map<string, TAny>>();
  return (cid = genId()) =>
    Promise.resolve({
      get sessionId() {
        return cid;
      },
      get data() {
        return store.get(cid) ?? new Map();
      },
      write(newData) {
        store.set(cid, newData);
        return Promise.resolve();
      },
      destroy() {
        store.delete(cid);
        return Promise.resolve();
      },
    });
}

function createSession<
  Data extends PrimitivesRecord,
  FlashMessage extends PrimitivesRecord,
>(storage: SessionStorage) {
  let destroyed = false;
  const flashKey = "__flash_",
    flash = (key: string) => `${flashKey}${key}__`,
    clonedMap = new Map(storage.data.entries()),
    sessionImpl: BaseSession<Data, FlashMessage> = {
      get destroyed() {
        return destroyed;
      },
      get sessionId() {
        return storage.sessionId;
      },
      get data() {
        return clonedMap;
      },
      flash(key, value) {
        if (typeof value === "undefined") {
          const v = clonedMap.get(flash(key as string));
          clonedMap.delete(flash(key as string));
          return v as TAny;
        }
        clonedMap.set(key as string, value);
      },
      destroy() {
        clonedMap.clear();
        destroyed = true;
      },
    };
  return new Proxy(sessionImpl, {
    get(target, p, _receiver) {
      if (p in target) return target[p as keyof typeof sessionImpl];
      return clonedMap.get(p as string);
    },
    set(target, p, newValue, _receiver) {
      if (p in target) return false;
      clonedMap.set(p as string, newValue);
      return true;
    },
    deleteProperty(target, p) {
      if (p in target) return false;
      clonedMap.delete(p as string);
      return true;
    },
    has(target, p) {
      if (p in target) return false;
      return clonedMap.has(p as never);
    },
  }) as unknown as Session<Data, FlashMessage>;
}

export function createSessionFactory(
  {
    cookieName = "__kodok_session",
    createStorage = createMemoryStorage(),
    cookieOptions = {},
    secret,
  }: Options = {},
): SessionFactory {
  if (secret) {
    console.warn(`Secret options is not implemented yet.`);
  }
  // default options
  cookieOptions = {
    httpOnly: true,
    path: "/",
    sameSite: "Lax",
    ...cookieOptions,
  };

  let storage: SessionStorage | undefined;
  return {
    async getSession(req) {
      const cid = getCookies(req.headers)[cookieName] as string | undefined;
      storage = await createStorage(cid);
      return createSession(storage);
    },
    async commitSession(res, session) {
      if (!storage) return res;
      if (session.destroyed) {
        await storage.destroy();
      } else {
        await storage.write(session.data);
      }
      setCookie(res.headers, {
        ...cookieOptions,
        name: cookieName,
        value: session.sessionId,
        unparsed: undefined,
      });
      return res;
    },
  };
}


Deno typed session