@absolutejs/auth 0.30.0-beta.4 → 0.30.0-beta.6

package/dist/oidc/clientAuth.d.ts

@@ -6,3 +6,10 @@ export declare const verifyClientAssertion: ({ assertion, expectedAudience, jtiS
     jtiStore?: ClientAssertionJtiStore;
     resolveClient: (clientId: string) => Promise<OAuthClient | undefined>;
 }) => Promise<OAuthClient | undefined>;
+export declare const verifyJwtSignedByClient: ({ jwt, client }: {
+    client: OAuthClient;
+    jwt: string;
+}) => Promise<{
+    header: any;
+    payload: any;
+} | undefined>;

package/dist/oidc/jar.d.ts

@@ -0,0 +1,14 @@
+import type { OAuthClient } from './types';
+export type JarParseResult = {
+    error: 'invalid_request_object';
+    ok: false;
+} | {
+    ok: true;
+    params: Record<string, string>;
+};
+export declare const parseSignedRequestObject: ({ client, expectedIssuer, jwt, now }: {
+    client: OAuthClient;
+    expectedIssuer: string;
+    jwt: string;
+    now?: number;
+}) => Promise<JarParseResult>;

package/dist/oidc/postgresStores.d.ts

@@ -347,6 +347,40 @@ export declare const oauthClientsTable: import("drizzle-orm/pg-core").PgTableWit
             }, {}, {}, import("drizzle-orm").ColumnBuilderExtraConfig>;
             size: undefined;
         }>;
+        require_pushed_authorization_requests: import("drizzle-orm/pg-core").PgColumn<{
+            name: "require_pushed_authorization_requests";
+            tableName: "auth_oauth_clients";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        require_signed_request_object: import("drizzle-orm/pg-core").PgColumn<{
+            name: "require_signed_request_object";
+            tableName: "auth_oauth_clients";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
         scopes: import("drizzle-orm/pg-core").PgColumn<{
             name: "scopes";
             tableName: "auth_oauth_clients";

package/dist/oidc/routes.d.ts

@@ -31,6 +31,7 @@ export declare const oidcProviderRoutes: <UserType>(config: OidcProviderConfig<U
                 scope?: string | undefined;
                 claims?: string | undefined;
                 nonce?: string | undefined;
+                request?: string | undefined;
                 redirect_uri?: string | undefined;
                 acr_values?: string | undefined;
                 code_challenge?: string | undefined;

package/dist/oidc/types.d.ts

@@ -8,6 +8,7 @@ export type OAuthClient = {
     postLogoutRedirectUris?: string[];
     redirectUris: string[];
     requirePushedAuthorizationRequests?: boolean;
+    requireSignedRequestObject?: boolean;
     scopes: string[];
 };
 export type ClientAssertionJtiStore = {

package/dist/sso/config.d.ts

@@ -57,6 +57,44 @@ export type SamlLogoutInfo = {
     requestId?: string;
     sessionIndex?: string;
 };
+export type SamlAuthnRequestInfo = {
+    acsUrl?: string;
+    forceAuthn?: boolean;
+    id: string;
+    issuer: string;
+    relayState?: string;
+};
+export type SamlIdpResponseRequest = {
+    acsUrl: string;
+    attributes?: Record<string, unknown>;
+    audience: string;
+    idpEntityId: string;
+    inResponseTo?: string;
+    nameId: string;
+    nameIdFormat?: string;
+    relayState?: string;
+    sessionIndex: string;
+};
+export type SamlIdpAdapter = {
+    buildAutoPostForm: (input: {
+        acsUrl: string;
+        relayState?: string;
+        samlResponse: string;
+    }) => string;
+    createSamlResponse: (request: SamlIdpResponseRequest) => Promise<string> | string;
+    getIdpMetadata: (input: {
+        entityId: string;
+        ssoUrl: string;
+    }) => Promise<string> | string;
+    parseAuthnRequest: (input: {
+        binding: 'POST' | 'Redirect';
+        samlRequest: string;
+        serviceProvider?: import('./types').SamlServiceProvider;
+        signature?: string;
+        signatureAlgorithm?: string;
+        signedQueryString?: string;
+    }) => Promise<SamlAuthnRequestInfo> | SamlAuthnRequestInfo;
+};
 export type SamlAdapter = {
     createAuthorizationUrl: (request: SamlAuthorizeRequest) => Promise<string> | string;
     createLogoutRequestUrl?: (request: SamlLogoutRequest) => Promise<string> | string;

package/dist/sso/inMemorySamlServiceProviderStore.d.ts

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

package/dist/sso/postgresSamlServiceProviderStore.d.ts

@@ -0,0 +1,119 @@
+import { type AnyPgDatabase } from '../stores/postgres';
+import type { SamlServiceProviderStore } from './types';
+export declare const samlServiceProvidersTable: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "auth_saml_service_providers";
+    schema: undefined;
+    columns: {
+        acs_url: import("drizzle-orm/pg-core").PgColumn<{
+            name: "acs_url";
+            tableName: "auth_saml_service_providers";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 2048;
+        }>;
+        created_at_ms: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at_ms";
+            tableName: "auth_saml_service_providers";
+            dataType: "number";
+            columnType: "PgBigInt53";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        entity_id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "entity_id";
+            tableName: "auth_saml_service_providers";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 2048;
+        }>;
+        name_id_format: import("drizzle-orm/pg-core").PgColumn<{
+            name: "name_id_format";
+            tableName: "auth_saml_service_providers";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 255;
+        }>;
+        signing_cert: import("drizzle-orm/pg-core").PgColumn<{
+            name: "signing_cert";
+            tableName: "auth_saml_service_providers";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updated_at_ms: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at_ms";
+            tableName: "auth_saml_service_providers";
+            dataType: "number";
+            columnType: "PgBigInt53";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export declare const createNeonSamlServiceProviderStore: (databaseUrl: string) => SamlServiceProviderStore;
+export declare const createPostgresSamlServiceProviderStore: (db: AnyPgDatabase) => SamlServiceProviderStore;

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/types.d.ts

@@ -29,6 +29,20 @@ export type SamlConnection = SSOConnectionBase & {
     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>;

package/package.json

@@ -1,5 +1,5 @@
 {
-	"version": "0.30.0-beta.4",
+	"version": "0.30.0-beta.6",
 	"name": "@absolutejs/auth",
 	"description": "An authorization library for absolutejs",
 	"repository": {