@absolutejs/auth 0.56.4 → 0.56.6

package/dist/htmx/routes.d.ts

@@ -0,0 +1,514 @@
+import { Elysia } from 'elysia';
+import type { AuthSessionSource } from '../session/types';
+import type { AuthHtmxConfig, AuthHtmxUser } from './types';
+export declare const createAuthHtmxRoutes: <UserType extends AuthHtmxUser>(config: AuthHtmxConfig & {
+    authSessionStore?: AuthSessionSource<UserType>;
+}) => Elysia<"", {
+    decorator: {};
+    store: {
+        session: import("..").SessionRecord<UserType>;
+        unregisteredSession: import("..").UnregisteredSessionRecord;
+    };
+    derive: {
+        readonly protectRoute: <AuthReturn, AuthFailReturn>(handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: ((error: {
+            readonly code: "Bad Request";
+            readonly message: "Cookies are missing";
+        } | {
+            readonly code: "Unauthorized";
+            readonly message: "User is not authenticated";
+        }) => AuthFailReturn) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "User is not authenticated", 401> | AuthReturn | NonNullable<AuthFailReturn>>;
+    };
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+} & {
+    schema: import("elysia").UnwrapRoute<{
+        cookie: import("@sinclair/typebox").TObject<{
+            user_session_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TTemplateLiteralSyntax<"${string}-${string}-${string}-${string}-${string}">>;
+        }>;
+    }, {}, "">;
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: import("elysia").ExtractErrorFromHandle<{
+        readonly protectRoute: <AuthReturn, AuthFailReturn>(handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: ((error: {
+            readonly code: "Bad Request";
+            readonly message: "Cookies are missing";
+        } | {
+            readonly code: "Unauthorized";
+            readonly message: "User is not authenticated";
+        }) => AuthFailReturn) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "User is not authenticated", 401> | AuthReturn | NonNullable<AuthFailReturn>>;
+    }>;
+}, {
+    htmx: {
+        login: {
+            get: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: Response;
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    htmx: {
+        link: {
+            get: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: Response;
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    htmx: {
+        "connector-links": {
+            get: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: Response;
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    htmx: {
+        "auth-menu": {
+            get: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    400: "Cookies are missing";
+                    401: "User is not authenticated";
+                    200: Response;
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    htmx: {
+        me: {
+            get: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    400: "Cookies are missing";
+                    401: "User is not authenticated";
+                    200: Response;
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    htmx: {
+        account: {
+            get: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    400: "Cookies are missing";
+                    401: "User is not authenticated";
+                    200: Response;
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    htmx: {
+        identities: {
+            get: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    400: "Cookies are missing";
+                    401: "User is not authenticated";
+                    200: {} | Response;
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    htmx: {
+        identities: {
+            ":id": {
+                primary: {
+                    post: {
+                        body: unknown;
+                        params: {
+                            id: string;
+                        } & {};
+                        query: unknown;
+                        headers: unknown;
+                        response: {
+                            400: "Cookies are missing";
+                            401: "User is not authenticated";
+                            200: {} | Response;
+                            422: {
+                                type: "validation";
+                                on: string;
+                                summary?: string;
+                                message?: string;
+                                found?: unknown;
+                                property?: string;
+                                expected?: string;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+} & {
+    htmx: {
+        identities: {
+            ":id": {
+                delete: {
+                    body: unknown;
+                    params: {
+                        id: string;
+                    } & {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        400: "Cookies are missing";
+                        401: "User is not authenticated";
+                        200: {} | Response;
+                        422: {
+                            type: "validation";
+                            on: string;
+                            summary?: string;
+                            message?: string;
+                            found?: unknown;
+                            property?: string;
+                            expected?: string;
+                        };
+                    };
+                };
+            };
+        };
+    };
+} & {
+    htmx: {
+        merge: {
+            ":id": {
+                post: {
+                    body: unknown;
+                    params: {
+                        id: string;
+                    } & {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        400: "Cookies are missing";
+                        401: "User is not authenticated";
+                        200: {} | Response;
+                        422: {
+                            type: "validation";
+                            on: string;
+                            summary?: string;
+                            message?: string;
+                            found?: unknown;
+                            property?: string;
+                            expected?: string;
+                        };
+                    };
+                };
+            };
+        };
+    };
+} & {
+    htmx: {
+        merge: {
+            ":id": {
+                delete: {
+                    body: unknown;
+                    params: {
+                        id: string;
+                    } & {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        400: "Cookies are missing";
+                        401: "User is not authenticated";
+                        200: {} | Response;
+                        422: {
+                            type: "validation";
+                            on: string;
+                            summary?: string;
+                            message?: string;
+                            found?: unknown;
+                            property?: string;
+                            expected?: string;
+                        };
+                    };
+                };
+            };
+        };
+    };
+} & {
+    htmx: {
+        "connector-list": {
+            get: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    400: "Cookies are missing";
+                    401: "User is not authenticated";
+                    200: Response;
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    htmx: {
+        connectors: {
+            grants: {
+                ":id": {
+                    delete: {
+                        body: unknown;
+                        params: {
+                            id: string;
+                        } & {};
+                        query: unknown;
+                        headers: unknown;
+                        response: {
+                            400: "Cookies are missing";
+                            401: "User is not authenticated";
+                            200: {} | Response;
+                            422: {
+                                type: "validation";
+                                on: string;
+                                summary?: string;
+                                message?: string;
+                                found?: unknown;
+                                property?: string;
+                                expected?: string;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+} & {
+    htmx: {
+        connectors: {
+            bindings: {
+                ":id": {
+                    delete: {
+                        body: unknown;
+                        params: {
+                            id: string;
+                        } & {};
+                        query: unknown;
+                        headers: unknown;
+                        response: {
+                            400: "Cookies are missing";
+                            401: "User is not authenticated";
+                            200: {} | Response;
+                            422: {
+                                type: "validation";
+                                on: string;
+                                summary?: string;
+                                message?: string;
+                                found?: unknown;
+                                property?: string;
+                                expected?: string;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+} & {
+    htmx: {
+        "login-redirect": {
+            get: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: Response;
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    htmx: {
+        "delete-account": {
+            post: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    400: "Cookies are missing";
+                    401: "User is not authenticated";
+                    200: {} | Response;
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    htmx: {
+        signout: {
+            get: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: Response;
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+} & {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/htmx/types.d.ts

@@ -0,0 +1,129 @@
+/** Minimal shape the account/menu/protected fragments read off the resolved
+ *  user. The consumer's full user record is structurally assignable. */
+export type AuthHtmxUser = {
+    sub: string;
+    email?: string | null;
+    first_name?: string | null;
+    last_name?: string | null;
+    primary_auth_identity_id?: string | null;
+};
+export type AuthHtmxProviderInfo = {
+    name: string;
+    logoUrl: string;
+};
+/** Per-provider display data (name + logo) keyed by provider option. */
+export type AuthHtmxProviderData = Record<string, AuthHtmxProviderInfo>;
+export type AuthHtmxConnectorTarget = {
+    provider: string;
+    label: string;
+    description: string;
+};
+/** OAuth client a provider authorization URL targets. Providers configured
+ *  with separate login/connector clients use this to disambiguate. */
+export type AuthHtmxClient = 'login' | 'connector';
+export type AuthIdentitySummary = {
+    id: string;
+    provider_subject: string;
+    isPrimary?: boolean;
+};
+export type AuthIdentityMergeRequestSummary = {
+    id: string;
+    status: string;
+    conflicting_auth_provider: string;
+    conflicting_provider_subject: string;
+};
+export type AuthIdentityPayload = {
+    identities: Record<string, AuthIdentitySummary[]>;
+    mergeRequests: AuthIdentityMergeRequestSummary[];
+};
+export type LinkedProviderBindingSummary = {
+    id: string;
+    label?: string | null;
+    externalAccountId: string;
+    connectorProvider: string;
+    externalAccountType: string;
+    status: string;
+    availableScopes: string[];
+};
+export type LinkedProviderGrantSummary = {
+    id: string;
+    authProviderKey: string;
+    status: string;
+    providerSubject: string;
+    grantedScopes: string[];
+};
+export type LinkedProviderPayload = {
+    bindings: LinkedProviderBindingSummary[];
+    grants: LinkedProviderGrantSummary[];
+};
+/** Per-fragment overrides. Any renderer left unset uses the package default. */
+export type AuthHtmxRenderOverrides = {
+    account?: (user: AuthHtmxUser) => string;
+    authMenu?: (user: AuthHtmxUser | null) => string;
+    connectorLinks?: () => string;
+    connectors?: (payload: LinkedProviderPayload) => string;
+    identities?: (payload: AuthIdentityPayload, query: string) => string;
+    protected?: (user: AuthHtmxUser) => string;
+    providerLogin?: (verb: string, includeDropdown: boolean) => string;
+};
+export type AuthHtmxRenderersConfig = {
+    /** Display data (name + logo) for every provider the UI references. */
+    providerData: AuthHtmxProviderData;
+    /** Providers shown as one-tap login buttons, in order. */
+    featuredLoginProviders: string[];
+    /** Connector targets shown on the connectors page. */
+    connectorTargets: AuthHtmxConnectorTarget[];
+    /** Builds the OAuth2 authorization URL for a provider. Defaults to
+     *  `/oauth2/<provider>/authorization` (with `?client=<client>` when a
+     *  client is given). Override to add per-provider client routing. */
+    authorizationHref?: (provider: string, client?: AuthHtmxClient) => string;
+    /** Per-fragment overrides. */
+    render?: AuthHtmxRenderOverrides;
+};
+export type ResolvedAuthHtmxRenderers = Required<AuthHtmxRenderOverrides> & {
+    escapeHtml: (value: string) => string;
+};
+/** Config for the `htmx` option on `auth`. Extends the renderers
+ *  config with the data actions the fragment routes call — keeping the auth
+ *  package agnostic of your identity schema while it owns the route wiring
+ *  (protectRoute gating, payload re-rendering, signout, delete-account flow). */
+export type AuthHtmxConfig = AuthHtmxRenderersConfig & {
+    /** Load the current user's grouped identities + pending merge requests. */
+    loadAuthIdentities: (userSub: string) => AuthIdentityPayload | Promise<AuthIdentityPayload>;
+    /** Load the current user's connector grants + external-account bindings. */
+    loadLinkedProviders: (userSub: string) => LinkedProviderPayload | Promise<LinkedProviderPayload>;
+    /** Promote an identity to the user's primary. */
+    setPrimaryIdentity: (input: {
+        identityId: string;
+        userSub: string;
+    }) => void | Promise<unknown>;
+    /** Remove an identity (the route already guards last-identity + primary). */
+    removeIdentity: (input: {
+        identityId: string;
+        userSub: string;
+    }) => void | Promise<unknown>;
+    /** Accept a pending merge request into the current user. */
+    mergeIdentity: (input: {
+        mergeRequestId: string;
+        userSub: string;
+    }) => void | Promise<unknown>;
+    /** Dismiss a pending merge request. */
+    dismissMergeRequest: (input: {
+        mergeRequestId: string;
+        userSub: string;
+    }) => void | Promise<unknown>;
+    /** Revoke a connector grant the user owns. */
+    removeGrant: (input: {
+        grantId: string;
+        userSub: string;
+    }) => void | Promise<unknown>;
+    /** Remove an external-account binding the user owns. */
+    removeBinding: (input: {
+        bindingId: string;
+        userSub: string;
+    }) => void | Promise<unknown>;
+    /** Delete the user's account and all linked data. */
+    deleteAccount: (input: {
+        userSub: string;
+    }) => void | Promise<unknown>;
+};

package/dist/index.js

@@ -27164,6 +27164,20 @@ var createInMemoryOidcRefreshTokenStore = () => {
       const active = Array.from(tokens.values()).filter((token) => token.userId === userId && token.expiresAt > now);
       return Array.from(new Set(active.map((token) => token.clientId)));
     },
+    listConnections: async () => {
+      const now = Date.now();
+      const connections = new Map;
+      for (const token of tokens.values()) {
+        if (token.expiresAt <= now)
+          continue;
+        const connection = {
+          clientId: token.clientId,
+          userId: token.userId
+        };
+        connections.set(`${connection.userId}\x00${connection.clientId}`, connection);
+      }
+      return Array.from(connections.values());
+    },
     saveToken: async (token) => {
       tokens.set(token.tokenHash, { ...token });
     }
@@ -27584,6 +27598,13 @@ var createPostgresOidcRefreshTokenStore = (db) => ({
     const rows = await db.selectDistinct({ client_id: oauthRefreshTokensTable.client_id }).from(oauthRefreshTokensTable).where(and(eq(oauthRefreshTokensTable.user_id, userId), gt(oauthRefreshTokensTable.expires_at_ms, Date.now())));
     return rows.map((row) => row.client_id);
   },
+  listConnections: async () => {
+    const rows = await db.selectDistinct({
+      clientId: oauthRefreshTokensTable.client_id,
+      userId: oauthRefreshTokensTable.user_id
+    }).from(oauthRefreshTokensTable).where(gt(oauthRefreshTokensTable.expires_at_ms, Date.now()));
+    return rows;
+  },
   saveToken: async (token) => {
     await db.insert(oauthRefreshTokensTable).values(toRefreshValues(token));
   }
@@ -30241,5 +30262,5 @@ export {
   AGENT_CLAIM_GRANT_TYPE
 };
 
-//# debugId=D34A86CCB66C340164756E2164756E21
+//# debugId=6D5EA8306E36581E64756E2164756E21
 //# sourceMappingURL=index.js.map