@absolutejs/auth 0.65.1 → 0.65.3

package/dist/routes/requireAuth.d.ts

@@ -0,0 +1,43 @@
+import { Elysia } from 'elysia';
+import type { AuthSessionSource } from '../session/types';
+export declare const requireAuthPlugin: <UserType>({ authSessionStore }?: {
+    authSessionStore?: AuthSessionSource<UserType>;
+}) => Elysia<"", {
+    decorator: {};
+    store: {
+        session: import("..").SessionRecord<UserType>;
+        unregisteredSession: import("..").UnregisteredSessionRecord;
+    };
+    derive: {};
+    resolve: {
+        readonly user: NonNullable<UserType> | null;
+    };
+}, {
+    typebox: {};
+    error: {};
+}, {
+    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: {
+        401: "User is not authenticated";
+    };
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/routes/revoke.d.ts

@@ -0,0 +1,73 @@
+import { Elysia } from 'elysia';
+import type { AuthSessionStore } from '../session/types';
+import { ClientProviders, OnRevocationError, OnRevocationSuccess, RouteString } from '../types';
+type RevokeProps<UserType> = {
+    authSessionStore?: AuthSessionStore<UserType>;
+    clientProviders: ClientProviders;
+    revokeRoute?: RouteString;
+    onRevocationSuccess: OnRevocationSuccess;
+    onRevocationError: OnRevocationError;
+};
+export declare const revoke: <UserType>({ authSessionStore, clientProviders, revokeRoute, onRevocationSuccess, onRevocationError }: RevokeProps<UserType>) => Elysia<"", {
+    decorator: {};
+    store: {
+        session: import("..").SessionRecord<UserType>;
+        unregisteredSession: import("..").UnregisteredSessionRecord;
+    };
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        post: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                400: "Cookies are missing" | "Session has no access token to revoke";
+                401: "Provider is required" | "Client provider not found" | "Client variant is required" | "Client variant not found" | "No auth provider found" | "No user session found";
+                501: "Provider does not support revocation";
+                200: Response;
+                422: {
+                    type: "validation";
+                    on: string;
+                    summary?: string;
+                    message?: string;
+                    found?: unknown;
+                    property?: string;
+                    expected?: string;
+                };
+                500: "Failed to revoke token";
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+} & {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export {};

package/dist/routes/sessions.d.ts

@@ -0,0 +1,103 @@
+import { Elysia } from 'elysia';
+import type { SessionsRouteProps } from '../session/sessionsConfig';
+import type { UserSessionId } from '../types';
+type SessionSummary = {
+    authenticatedAt?: number;
+    current: boolean;
+    expiresAt: number;
+    id: UserSessionId;
+};
+export declare const sessionRoutes: <UserType>({ authSessionStore, getUserId, sessionsRoute }: SessionsRouteProps<UserType>) => Elysia<"", {
+    decorator: {};
+    store: {
+        session: import("..").SessionRecord<UserType>;
+        unregisteredSession: import("..").UnregisteredSessionRecord;
+    };
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                401: "Authentication required";
+                501: "Session management requires an authSessionStore";
+                200: {
+                    readonly sessions: SessionSummary[];
+                };
+                422: {
+                    type: "validation";
+                    on: string;
+                    summary?: string;
+                    message?: string;
+                    found?: unknown;
+                    property?: string;
+                    expected?: string;
+                };
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        ":id": {
+            delete: {
+                body: unknown;
+                params: {
+                    id: string;
+                };
+                query: unknown;
+                headers: unknown;
+                response: {
+                    400: "Invalid session id";
+                    401: "Authentication required";
+                    501: "Session management requires an authSessionStore";
+                    404: "Session not found";
+                    200: {
+                        readonly revoked: `${string}-${string}-${string}-${string}-${string}`;
+                    };
+                    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: {};
+}>;
+export {};

package/dist/routes/signout.d.ts

@@ -0,0 +1,70 @@
+import { Elysia } from 'elysia';
+import type { AuthSessionStore } from '../session/types';
+import { OnSignOut, RouteString, type SessionRecord } from '../types';
+type SignOutProps<UserType> = {
+    authSessionStore?: AuthSessionStore<UserType>;
+    signoutRoute?: RouteString;
+    onSignOut: OnSignOut<UserType>;
+};
+export declare const signout: <UserType>({ authSessionStore, signoutRoute, onSignOut }: SignOutProps<UserType>) => Elysia<"", {
+    decorator: {};
+    store: {
+        session: SessionRecord<UserType>;
+        unregisteredSession: import("..").UnregisteredSessionRecord;
+    };
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        delete: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                400: "Cookies are missing";
+                401: "No user session id found";
+                200: Response;
+                422: {
+                    type: "validation";
+                    on: string;
+                    summary?: string;
+                    message?: string;
+                    found?: unknown;
+                    property?: string;
+                    expected?: string;
+                };
+                500: "Sign out operation failed";
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+} & {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export {};

package/dist/routes/stepUp.d.ts

@@ -0,0 +1,48 @@
+import { Elysia } from 'elysia';
+import type { AuthSessionSource } from '../session/types';
+type ReauthFailError = {
+    readonly code: 'Unauthorized';
+    readonly message: 'Recent authentication required';
+};
+export declare const stepUpPlugin: <UserType>({ authSessionStore }?: {
+    authSessionStore?: AuthSessionSource<UserType>;
+}) => Elysia<"", {
+    decorator: {};
+    store: {
+        session: import("..").SessionRecord<UserType>;
+        unregisteredSession: import("..").UnregisteredSessionRecord;
+    };
+    derive: {
+        readonly requireRecentAuth: <AuthReturn, AuthFailReturn>(maxAgeMs: number, handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: ReauthFailError) => AuthFailReturn) => Promise<AuthReturn | import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "Recent authentication required", 401> | NonNullable<AuthFailReturn>>;
+    };
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    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 requireRecentAuth: <AuthReturn, AuthFailReturn>(maxAgeMs: number, handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: ReauthFailError) => AuthFailReturn) => Promise<AuthReturn | import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "Recent authentication required", 401> | NonNullable<AuthFailReturn>>;
+    }>;
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export {};

package/dist/routes/userStatus.d.ts

@@ -0,0 +1,72 @@
+import { Elysia } from 'elysia';
+import type { AuthSessionStore } from '../session/types';
+import { OnStatus, RouteString } from '../types';
+type StatusProps<UserType> = {
+    authSessionStore?: AuthSessionStore<UserType>;
+    statusRoute?: RouteString;
+    onStatus: OnStatus<UserType>;
+};
+export declare const userStatus: <UserType>({ authSessionStore, statusRoute, onStatus }: StatusProps<UserType>) => Elysia<"", {
+    decorator: {};
+    store: {
+        session: import("..").SessionRecord<UserType>;
+        unregisteredSession: import("..").UnregisteredSessionRecord;
+    };
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                400: "Cookies are missing";
+                200: {
+                    impersonator: import("..").Impersonator | undefined;
+                    user: NonNullable<UserType> | null;
+                };
+                422: {
+                    type: "validation";
+                    on: string;
+                    summary?: string;
+                    message?: string;
+                    found?: unknown;
+                    property?: string;
+                    expected?: string;
+                };
+                500: `Error: ${string} - ${string}` | `Unknown Error: ${string}`;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+} & {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export {};

package/dist/saml.d.ts

@@ -0,0 +1 @@
+export { createNodeSamlAdapter, type NodeSamlAdapterOptions } from './sso/nodeSamlAdapter';

package/dist/scim/config.d.ts

@@ -0,0 +1,57 @@
+import type { OrganizationId } from '../tenancy';
+import type { RouteString } from '../types';
+import type { ScimAttributeMap } from './extensions';
+import type { ScimFilter, ScimGroup, ScimGroupInput, ScimTokenStore, ScimUser, ScimUserInput } from './types';
+export declare const DEFAULT_SCIM_ROUTE = "/scim/v2";
+export type ScimConfig = {
+    customAttributes?: ScimAttributeMap;
+    getScimGroup?: (context: {
+        id: string;
+        organizationId: OrganizationId;
+    }) => ScimGroup | undefined | Promise<ScimGroup | undefined>;
+    getScimUser: (context: {
+        id: string;
+        organizationId: OrganizationId;
+    }) => ScimUser | undefined | Promise<ScimUser | undefined>;
+    listScimGroups?: (context: {
+        filter?: ScimFilter;
+        organizationId: OrganizationId;
+    }) => ScimGroup[] | Promise<ScimGroup[]>;
+    listScimUsers: (context: {
+        filter?: ScimFilter;
+        organizationId: OrganizationId;
+    }) => ScimUser[] | Promise<ScimUser[]>;
+    onScimGroupCreate?: (context: {
+        input: ScimGroupInput;
+        organizationId: OrganizationId;
+    }) => ScimGroup | Promise<ScimGroup>;
+    onScimGroupDelete?: (context: {
+        id: string;
+        organizationId: OrganizationId;
+    }) => void | Promise<void>;
+    onScimGroupReplace?: (context: {
+        id: string;
+        input: ScimGroupInput;
+        organizationId: OrganizationId;
+    }) => ScimGroup | undefined | Promise<ScimGroup | undefined>;
+    onScimUserCreate: (context: {
+        input: ScimUserInput;
+        organizationId: OrganizationId;
+    }) => ScimUser | Promise<ScimUser>;
+    onScimUserDeactivate: (context: {
+        id: string;
+        organizationId: OrganizationId;
+    }) => void | Promise<void>;
+    onScimUserReplace: (context: {
+        id: string;
+        input: ScimUserInput;
+        organizationId: OrganizationId;
+    }) => ScimUser | undefined | Promise<ScimUser | undefined>;
+    scimRoute?: RouteString;
+    scimTokenStore: ScimTokenStore;
+};
+export declare const createScimToken: (scimTokenStore: ScimTokenStore, organizationId: OrganizationId) => Promise<{
+    token: string;
+    tokenId: string;
+}>;
+export declare const resolveScimOrganization: (scimTokenStore: ScimTokenStore, authorization: string | undefined) => Promise<string | undefined>;

package/dist/scim/extensions.d.ts

@@ -0,0 +1,30 @@
+import type { ScimGroupMember } from './types';
+export type ScimAttributeDefinition = {
+    caseExact?: boolean;
+    description?: string;
+    multiValued?: boolean;
+    mutability?: 'immutable' | 'readOnly' | 'readWrite' | 'writeOnly';
+    name: string;
+    required?: boolean;
+    returned?: 'always' | 'default' | 'never' | 'request';
+    subAttributes?: ScimAttributeDefinition[];
+    type: 'boolean' | 'complex' | 'dateTime' | 'decimal' | 'integer' | 'reference' | 'string';
+    uniqueness?: 'global' | 'none' | 'server';
+};
+export type ScimSchemaDefinition = {
+    attributes: ScimAttributeDefinition[];
+    description?: string;
+    id: string;
+    name: string;
+};
+export type ScimAttributeMap = {
+    fromScim: (body: Record<string, unknown>) => Record<string, unknown>;
+    schemas?: ScimSchemaDefinition[];
+    toScim: (custom: Record<string, unknown>) => Record<string, unknown>;
+};
+export declare const defineScimAttributeMap: (map: ScimAttributeMap) => ScimAttributeMap;
+export type ScimGroupMembershipDelta = {
+    added: ScimGroupMember[];
+    removed: ScimGroupMember[];
+};
+export declare const diffScimGroupMembers: (current: ScimGroupMember[], next: ScimGroupMember[]) => ScimGroupMembershipDelta;

package/dist/scim/inMemoryScimTokenStore.d.ts

@@ -0,0 +1,2 @@
+import type { ScimTokenStore } from './types';
+export declare const createInMemoryScimTokenStore: () => ScimTokenStore;

package/dist/scim/postgresScimTokenStore.d.ts

@@ -0,0 +1,86 @@
+import { type AnyPgDatabase } from '../stores/postgres';
+import type { ScimTokenStore } from './types';
+export declare const scimTokensTable: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "auth_scim_tokens";
+    schema: undefined;
+    columns: {
+        created_at_ms: import("drizzle-orm/pg-core").PgBuildColumn<"auth_scim_tokens", import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgBigInt53Builder>, {
+            name: string;
+            tableName: "auth_scim_tokens";
+            dataType: "number int53";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        hashed_token: import("drizzle-orm/pg-core").PgBuildColumn<"auth_scim_tokens", import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgVarcharBuilder<[string, ...string[]]>>, {
+            name: string;
+            tableName: "auth_scim_tokens";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        last_used_at_ms: import("drizzle-orm/pg-core").PgBuildColumn<"auth_scim_tokens", import("drizzle-orm/pg-core").PgBigInt53Builder, {
+            name: string;
+            tableName: "auth_scim_tokens";
+            dataType: "number int53";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        organization_id: import("drizzle-orm/pg-core").PgBuildColumn<"auth_scim_tokens", import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgVarcharBuilder<[string, ...string[]]>>, {
+            name: string;
+            tableName: "auth_scim_tokens";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        token_id: import("drizzle-orm/pg-core").PgBuildColumn<"auth_scim_tokens", import("drizzle-orm/pg-core").SetIsPrimaryKey<import("drizzle-orm/pg-core").PgVarcharBuilder<[string, ...string[]]>>, {
+            name: string;
+            tableName: "auth_scim_tokens";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+    };
+    dialect: "pg";
+}>;
+export declare const createNeonScimTokenStore: (databaseUrl: string) => ScimTokenStore;
+export declare const createPostgresScimTokenStore: <DB extends AnyPgDatabase>(db: DB) => ScimTokenStore;