@leaguebrain/provenance 0.0.0-stage → 0.14.0

package/dist/index.d.ts

@@ -0,0 +1,210 @@
+import { R as Resolver, P as Provider } from './index-CPpCO-Oc.js';
+export { a as ProviderCallbacks, g as github, k as keycloak, p as provider } from './index-CPpCO-Oc.js';
+import { SerializeOptions } from 'cookie';
+import { T as TokenRequestResult } from './context-C2cW461e.js';
+export { C as Context } from './context-C2cW461e.js';
+
+declare const localsResolver: <Session>() => Resolver<Session>;
+
+declare const loginResolver: <Session>() => Resolver<Session>;
+
+declare const logoutResolver: <Session>() => Resolver<Session>;
+
+declare const redirectUriResolver: <Session>() => Resolver<Session>;
+
+declare const refreshResolver: <Session extends {
+    refreshToken: string;
+    accessExpiresAt: number;
+    refreshExpiresAt?: number;
+}>(options: {
+    /** in ms */
+    eagerRefresh: number;
+}) => Resolver<Session>;
+
+declare const signupResolver: <Session>() => Resolver<Session>;
+
+declare const c: <State extends Record<string, any>>() => {
+    state: {
+        create(data: State): {
+            state: string;
+            cookie: Cookie;
+        };
+        use(cookies: Cookies): string;
+        decode(state: string): State;
+    };
+    pkce: {
+        create(): Promise<{
+            codeChallenge: string;
+            cookie: Cookie;
+        }>;
+        use(cookies: Cookies): string;
+    };
+};
+type ChecksModule<State extends Record<string, any>> = ReturnType<typeof c<State>>;
+
+declare const o: <Session>(modules: {
+    checks: ChecksModule<{
+        referrer?: string;
+    }>;
+}, provider: Provider<Session>, options: {
+    redirectUriPathname: string;
+}) => {
+    /**
+     * create a redirect to the auth server for the user to login
+     * @param redirectUriOrigin origin for redirect uri.. typically the origin of the website that is logging in
+     * @param referrer the path that initiated the login
+     * @param setCookie a callback that will be used to set oauth check values in cookies to be consumed by the redirect uri handler
+     * @returns the generated auth server url
+     */
+    login(redirectUriOrigin: string, referrer: string | null, setCookie: (name: string, value: string, opts: SerializeOptions & {
+        path: string;
+    }) => void): Promise<string>;
+    /**
+     * create a redirect to the auth server for the user to login
+     * @param redirectUriOrigin origin for redirect uri.. typically the origin of the website that is logging in
+     * @param referrer the path that initiated the login
+     * @param setCookie a callback that will be used to set oauth check values in cookies to be consumed by the redirect uri handler
+     * @returns the generated auth server url
+     */
+    signup(redirectUriOrigin: string, referrer: string | null, setCookie: (name: string, value: string, opts: SerializeOptions & {
+        path: string;
+    }) => void): Promise<string>;
+    /**
+     * post to the oauth logout endpoint to destroy the oauth session (not the session stored in the cookies)
+     * @param fetch
+     */
+    logout(fetch: (url: URL, body?: URLSearchParams) => Promise<Response>, session: Session): Promise<void>;
+    /**
+     * post to the oauth token endpoint to request a new set of tokens
+     * @param fetchRefreshedTokens
+     * @param refreshToken refreshToken as stored in session
+     * @returns fresh tokens
+     */
+    refresh(fetchRefreshedTokens: (url: URL, body: {
+        client_id: string;
+        client_secret: string;
+        grant_type: "refresh_token";
+        refresh_token: string;
+    }) => Promise<Response>, refreshToken: string): Promise<TokenRequestResult>;
+    /**
+     * process the redirect from the oauth auth endpoint with a one time authorization code in url params
+     * @param url the url (with params such as code) that the auth server redirects to after user logs in (get from the request event on redirectUri)
+     * @param expectedState state stored in a cookie by this client at the start of the auth flow
+     * @returns one time authorization code to be used with the token endpoint
+     */
+    processAuthResponse(url: URL, expectedState: string): {
+        code: string;
+        state: {
+            referrer?: string;
+        };
+    };
+    /**
+     * request a set of tokens from the oauth token endpoint using a one time authorization code
+     * @param fetchRequestToken callback that contains the fetch call
+     * @returns brand new tokens
+     */
+    requestToken(fetchRequestToken: (url: URL, params: {
+        clientId: string;
+        clientSecret: string;
+        redirectUri: string;
+    }) => Promise<Response>): Promise<TokenRequestResult>;
+};
+type OAuthModule = ReturnType<typeof o>;
+
+declare const r: (options: {
+    redirectUriPathname: string;
+    loginPathname: string;
+    signupPathname: string;
+    logoutPathname: string;
+    refreshPathname: string;
+    homePathname: string;
+}) => {
+    redirectUri: {
+        pathname: string;
+    };
+    login: {
+        pathname: string;
+    };
+    signup: {
+        pathname: string;
+    };
+    logout: {
+        pathname: string;
+    };
+    refresh: {
+        pathname: string;
+    };
+    home: {
+        pathname: string;
+    };
+};
+type RoutesModule = ReturnType<typeof r>;
+
+declare const s: <Session>(provider: Provider<Session>, options: {
+    sessionCookieName: string;
+}) => {
+    /**
+     * create a session object from a set of tokens
+     * @param tokens
+     * @returns session to be stored in cookies
+     */
+    create(tokens: TokenRequestResult): Session;
+    /**
+     * set the session object in cookies, splitting into chunks if too large
+     * @param cookies cookies from request event
+     * @param sessionCookieName
+     * @param session the session object to be set in cookies
+     */
+    setCookie(set: (name: string, value: string, maxAge: number) => void, session: Session): void;
+    /**
+     * get the session object from cookies
+     * @param getAll call back for retrieving cookies
+     * @returns the session object stored in cookies or null if there is no session stored
+     */
+    getCookie(getAll: () => {
+        name: string;
+        value: string;
+    }[]): Session | null;
+    /**
+     * expire the session object in cookies
+     * @param cookies cookies from request event
+     * @param sessionCookieName
+     */
+    deleteCookie(getAll: () => {
+        name: string;
+        value: string;
+    }[], _delete: (name: string) => void): void;
+};
+type SessionModule<Session> = ReturnType<typeof s<Session>>;
+
+type Cookie = {
+    name: string;
+    value: string;
+    options: SerializeOptions & {
+        path: string;
+    };
+};
+type Cookies = {
+    get: (name: string) => string | undefined;
+    delete: (name: string, opts: SerializeOptions & {
+        path: string;
+    }) => void;
+};
+type AuthOptions = {
+    /** defaults to `/auth` */
+    redirectUriPathname?: string;
+    /** defaults to `session` */
+    sessionCookieName?: string;
+    /** defaults to `/login` */
+    loginPathname?: string;
+    /** defaults to `/signup` */
+    signupPathname?: string;
+    /** defaults to `/logout` */
+    logoutPathname?: string;
+    /** defaults to `/refresh` */
+    refreshPathname?: string;
+    /** defaults to `/` */
+    homePathname?: string;
+};
+
+export { type AuthOptions, type ChecksModule, type Cookie, type Cookies, type OAuthModule, Provider, Resolver, type RoutesModule, type SessionModule, TokenRequestResult, c, localsResolver, loginResolver, logoutResolver, o, r, redirectUriResolver, refreshResolver, s, signupResolver };