@absolutejs/auth 0.65.1 → 0.65.3

package/dist/sso/samlIdpRoutes.d.ts

@@ -0,0 +1,139 @@
+import { Elysia } from 'elysia';
+import type { AuthSessionStore } from '../session/types';
+import type { RouteString, SessionRecord } from '../types';
+import { type SamlIdpAdapter } from './config';
+import type { SamlServiceProviderStore } from './types';
+type SamlIdpRoutesProps<UserType> = {
+    authSessionStore?: AuthSessionStore<UserType>;
+    getNameId: (user: UserType) => string;
+    getSamlAttributes?: (user: UserType) => Record<string, unknown>;
+    idpAdapter: SamlIdpAdapter;
+    idpEntityId: string;
+    loginUrl?: string;
+    samlServiceProviderStore: SamlServiceProviderStore;
+    ssoRoute?: RouteString;
+};
+export declare const samlIdpRoutes: <UserType>({ authSessionStore, getNameId, getSamlAttributes, idpAdapter, idpEntityId, loginUrl, samlServiceProviderStore, ssoRoute }: SamlIdpRoutesProps<UserType>) => Elysia<"", {
+    decorator: {};
+    store: {
+        session: SessionRecord<UserType>;
+        unregisteredSession: import("..").UnregisteredSessionRecord;
+    };
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        post: {
+            body: {
+                RelayState?: string | undefined;
+                SAMLRequest?: string | undefined;
+            };
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response;
+                422: {
+                    type: "validation";
+                    on: string;
+                    summary?: string;
+                    message?: string;
+                    found?: unknown;
+                    property?: string;
+                    expected?: string;
+                };
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {};
+            query: {
+                RelayState?: string | undefined;
+                SAMLRequest?: string | undefined;
+                SigAlg?: string | undefined;
+                Signature?: string | undefined;
+            };
+            headers: unknown;
+            response: {
+                200: Response;
+                422: {
+                    type: "validation";
+                    on: string;
+                    summary?: string;
+                    message?: string;
+                    found?: unknown;
+                    property?: string;
+                    expected?: string;
+                };
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {};
+            query: {
+                RelayState?: string | undefined;
+                sp?: string | undefined;
+            };
+            headers: unknown;
+            response: {
+                200: Response;
+                422: {
+                    type: "validation";
+                    on: string;
+                    summary?: string;
+                    message?: string;
+                    found?: unknown;
+                    property?: string;
+                    expected?: string;
+                };
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+} & {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export {};

package/dist/sso/samlRoutes.d.ts

@@ -0,0 +1,179 @@
+import { Elysia } from 'elysia';
+import type { AuthSessionStore } from '../session/types';
+import type { SessionRecord } from '../types';
+import { type SamlAdapter, type SSOConfig } from './config';
+type SamlRoutesProps<UserType> = SSOConfig<UserType> & {
+    authSessionStore?: AuthSessionStore<UserType>;
+    cookieSecure?: boolean;
+    samlAdapter: SamlAdapter;
+};
+export declare const samlSsoRoutes: <UserType>({ authSessionStore, cookieSecure, getSsoUser, onSsoCallbackError, onSsoCallbackSuccess, samlAdapter, sessionDurationMs, ssoConnectionStore, ssoRoute }: SamlRoutesProps<UserType>) => Elysia<"", {
+    decorator: {};
+    store: {
+        session: SessionRecord<UserType>;
+        unregisteredSession: import("..").UnregisteredSessionRecord;
+    };
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {
+                organizationId: string;
+            };
+            query: unknown;
+            headers: unknown;
+            response: {
+                404: "No SAML connection is configured for this organization";
+                200: Response;
+                422: {
+                    type: "validation";
+                    on: string;
+                    summary?: string;
+                    message?: string;
+                    found?: unknown;
+                    property?: string;
+                    expected?: string;
+                };
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        post: {
+            body: {
+                RelayState?: string | undefined;
+                SAMLResponse: string;
+            };
+            params: {
+                organizationId: string;
+            };
+            query: unknown;
+            headers: unknown;
+            response: {
+                404: "No SAML connection is configured for this organization";
+                200: Response;
+                422: {
+                    type: "validation";
+                    on: string;
+                    summary?: string;
+                    message?: string;
+                    found?: unknown;
+                    property?: string;
+                    expected?: string;
+                };
+                500: "SAML sign-in failed";
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {
+                organizationId: string;
+            };
+            query: unknown;
+            headers: unknown;
+            response: {
+                404: "No SAML connection is configured for this organization";
+                200: Response;
+                422: {
+                    type: "validation";
+                    on: string;
+                    summary?: string;
+                    message?: string;
+                    found?: unknown;
+                    property?: string;
+                    expected?: string;
+                };
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {
+                organizationId: string;
+            };
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response;
+                422: {
+                    type: "validation";
+                    on: string;
+                    summary?: string;
+                    message?: string;
+                    found?: unknown;
+                    property?: string;
+                    expected?: string;
+                };
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {
+                organizationId: string;
+            };
+            query: {
+                RelayState?: string | undefined;
+                SAMLResponse?: string | undefined;
+                SAMLRequest?: string | undefined;
+                SigAlg?: string | undefined;
+                Signature?: string | undefined;
+            };
+            headers: unknown;
+            response: {
+                400: "Missing SAMLRequest or SAMLResponse" | "Invalid SAML LogoutRequest";
+                501: "SAML Single Logout is not configured";
+                404: "No SAML connection is configured for this organization";
+                200: Response;
+                422: {
+                    type: "validation";
+                    on: string;
+                    summary?: string;
+                    message?: string;
+                    found?: unknown;
+                    property?: string;
+                    expected?: string;
+                };
+                500: "SAML logout failed";
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+} & {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export {};

package/dist/sso/types.d.ts

@@ -0,0 +1,53 @@
+import type { OrganizationId } from '../tenancy';
+export type SSOConnectionType = 'oidc' | 'saml';
+export type OidcConnectionConfig = {
+    clientId: string;
+    clientSecret: string;
+    issuer: string;
+    redirectUri: string;
+    scopes: string[];
+};
+export type SamlConnectionConfig = {
+    idpEntityId: string;
+    idpSloUrl?: string;
+    idpSsoUrl: string;
+    idpX509Cert: string;
+};
+type SSOConnectionBase = {
+    connectionId: string;
+    createdAt: number;
+    enabled: boolean;
+    organizationId: OrganizationId;
+    updatedAt: number;
+};
+export type OidcConnection = SSOConnectionBase & {
+    config: OidcConnectionConfig;
+    type: 'oidc';
+};
+export type SamlConnection = SSOConnectionBase & {
+    config: SamlConnectionConfig;
+    type: 'saml';
+};
+export type SSOConnection = OidcConnection | SamlConnection;
+export type SamlServiceProvider = {
+    acsUrl: string;
+    createdAt: number;
+    entityId: string;
+    nameIdFormat?: string;
+    signingCert?: string;
+    updatedAt: number;
+};
+export type SamlServiceProviderStore = {
+    deleteServiceProvider: (entityId: string) => Promise<void>;
+    findServiceProvider: (entityId: string) => Promise<SamlServiceProvider | undefined>;
+    listServiceProviders: () => Promise<SamlServiceProvider[]>;
+    saveServiceProvider: (sp: SamlServiceProvider) => Promise<void>;
+};
+export type SSOConnectionStore = {
+    deleteConnection: (connectionId: string) => Promise<void>;
+    getConnection: (connectionId: string) => Promise<SSOConnection | undefined>;
+    getConnectionByOrganization: (organizationId: OrganizationId, type?: SSOConnectionType) => Promise<SSOConnection | undefined>;
+    listConnectionsByOrganization: (organizationId: OrganizationId) => Promise<SSOConnection[]>;
+    saveConnection: (connection: SSOConnection) => Promise<void>;
+};
+export {};

package/dist/stores/postgres.d.ts

@@ -0,0 +1,5 @@
+import type { PgAsyncDatabase, PgQueryResultHKT } from 'drizzle-orm/pg-core';
+export type AnyPgDatabase = PgAsyncDatabase<PgQueryResultHKT>;
+export declare const createNeonDatabase: (databaseUrl: string) => import("drizzle-orm/neon-http").NeonHttpDatabase<import("drizzle-orm").EmptyRelations> & {
+    $client: import("@neondatabase/serverless").NeonQueryFunction<false, false>;
+};

package/dist/stores/redis.d.ts

@@ -0,0 +1,5 @@
+export type RedisLike = {
+    del: (key: string) => Promise<unknown>;
+    get: (key: string) => Promise<string | null>;
+    set: (key: string, value: string, ttlMs: number) => Promise<unknown>;
+};

package/dist/telemetry/tracing.d.ts

@@ -0,0 +1,15 @@
+import type { Attributes, Span, TracerProvider } from '@opentelemetry/api';
+export type TracingConfig = {
+    /** Plug in your `@opentelemetry/sdk-trace-node` (or `-web` / `-bun`) TracerProvider
+     *  here. When omitted, every `withSpan` call short-circuits and the package never
+     *  loads `@opentelemetry/api`. */
+    tracerProvider: TracerProvider;
+    /** Service name attribute attached to every span. Defaults to `@absolutejs/auth`. */
+    serviceName?: string;
+};
+type SpanWork<Result> = (span: Span | undefined) => Promise<Result>;
+type WithSpanFn = <Result>(name: string, attributes: Attributes | undefined, work: SpanWork<Result>) => Promise<Result>;
+export declare const __resetTracingForTests: () => void;
+export declare const initTracing: (config: TracingConfig) => Promise<void>;
+export declare const withSpan: WithSpanFn;
+export {};

package/dist/tenancy.d.ts

@@ -0,0 +1,9 @@
+export type OrganizationId = string;
+export type WithOrganization<Resource> = Resource & {
+    organizationId?: OrganizationId;
+};
+export declare const hasOrganizationScope: (value: {
+    organizationId?: OrganizationId;
+}) => value is {
+    organizationId: OrganizationId;
+};

package/dist/typeGuards.d.ts

@@ -0,0 +1,6 @@
+import { AuthIntent, StatusReturn, UserSessionId } from './types';
+export declare const isValidUser: <UserType>(user: unknown) => user is UserType;
+export declare const isAuthIntent: (value: unknown) => value is AuthIntent;
+export declare const isNonEmptyString: (str: string | null | undefined) => str is string;
+export declare const isStatusResponse: (value: unknown) => value is StatusReturn;
+export declare const isUserSessionId: (key: string) => key is UserSessionId;

package/dist/typebox.d.ts

@@ -0,0 +1,4 @@
+export declare const authClientOption: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+export declare const authIntentOption: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"login">, import("@sinclair/typebox").TLiteral<"link_identity">, import("@sinclair/typebox").TLiteral<"link_connector">]>>;
+export declare const authProviderOption: import("@sinclair/typebox").TString;
+export declare const userSessionIdTypebox: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TTemplateLiteralSyntax<"${string}-${string}-${string}-${string}-${string}">>;