@absolutejs/auth 0.65.1 → 0.65.3

package/dist/scim/routes.d.ts

@@ -0,0 +1,366 @@
+import { Elysia } from 'elysia';
+import { type ScimConfig } from './config';
+export declare const scimRoutes: ({ customAttributes, getScimGroup, getScimUser, listScimGroups, listScimUsers, onScimGroupCreate, onScimGroupDelete, onScimGroupReplace, onScimUserCreate, onScimUserDeactivate, onScimUserReplace, scimRoute, scimTokenStore }: ScimConfig) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response;
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        post: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response;
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {};
+            query: {
+                filter?: 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: {
+                id: 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]: {
+        put: {
+            body: unknown;
+            params: {
+                id: 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]: {
+        patch: {
+            body: unknown;
+            params: {
+                id: 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]: {
+        delete: {
+            body: unknown;
+            params: {
+                id: 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]: {
+        post: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response;
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {};
+            query: {
+                filter?: 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: {
+                id: 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]: {
+        put: {
+            body: unknown;
+            params: {
+                id: 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]: {
+        patch: {
+            body: unknown;
+            params: {
+                id: 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]: {
+        delete: {
+            body: unknown;
+            params: {
+                id: 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: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response;
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {
+                id: 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: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response;
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {
+                id: string;
+            };
+            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: {};
+}>;

package/dist/scim/serialize.d.ts

@@ -0,0 +1,83 @@
+import type { ScimAttributeMap, ScimSchemaDefinition } from './extensions';
+import type { ScimFilter, ScimGroup, ScimGroupInput, ScimUser, ScimUserInput } from './types';
+declare const SCHEMA_SCHEMA = "urn:ietf:params:scim:schemas:core:2.0:Schema";
+declare const RESOURCE_TYPE_SCHEMA = "urn:ietf:params:scim:schemas:core:2.0:ResourceType";
+export declare const toUserResource: (user: ScimUser, location: string, map?: ScimAttributeMap) => Record<string, unknown>;
+export declare const parseUserInput: (body: unknown, map?: ScimAttributeMap) => ScimUserInput | undefined;
+export declare const applyPatch: (user: ScimUser, body: unknown) => ScimUserInput;
+export declare const listResponse: (resources: Record<string, unknown>[]) => {
+    itemsPerPage: number;
+    Resources: Record<string, unknown>[];
+    schemas: string[];
+    startIndex: number;
+    totalResults: number;
+};
+export declare const parseFilter: (filter: string | undefined) => ScimFilter | undefined;
+export declare const scimError: (httpStatus: number, detail: string, scimType?: string) => Response;
+export declare const scimJson: (resource: unknown, httpStatus: number) => Response;
+export declare const serviceProviderConfig: (location: string) => {
+    authenticationSchemes: {
+        description: string;
+        name: string;
+        primary: boolean;
+        specUri: string;
+        type: string;
+    }[];
+    bulk: {
+        maxOperations: number;
+        maxPayloadSize: number;
+        supported: boolean;
+    };
+    changePassword: {
+        supported: boolean;
+    };
+    etag: {
+        supported: boolean;
+    };
+    filter: {
+        maxResults: number;
+        supported: boolean;
+    };
+    meta: {
+        location: string;
+        resourceType: string;
+    };
+    patch: {
+        supported: boolean;
+    };
+    schemas: string[];
+    sort: {
+        supported: boolean;
+    };
+};
+export declare const schemaList: (location: string, extras?: ScimSchemaDefinition[]) => {
+    itemsPerPage: number;
+    Resources: Record<string, unknown>[];
+    schemas: string[];
+    startIndex: number;
+    totalResults: number;
+};
+export declare const schemaOne: (location: string, id: string, extras?: ScimSchemaDefinition[]) => Record<string, unknown> | undefined;
+export declare const resourceTypeList: (location: string, usersEndpoint: string, groupsEndpoint: string, extras?: ScimSchemaDefinition[]) => {
+    itemsPerPage: number;
+    Resources: Record<string, unknown>[];
+    schemas: string[];
+    startIndex: number;
+    totalResults: number;
+};
+export declare const resourceTypeOne: (location: string, id: string, usersEndpoint: string, groupsEndpoint: string, extras?: ScimSchemaDefinition[]) => {
+    description: string;
+    endpoint: string;
+    id: string;
+    meta: {
+        location: string;
+        resourceType: string;
+    };
+    name: string;
+    schema: string;
+    schemas: string[];
+} | undefined;
+export { RESOURCE_TYPE_SCHEMA, SCHEMA_SCHEMA };
+export declare const applyGroupPatch: (group: ScimGroup, body: unknown) => ScimGroupInput;
+export declare const parseGroupInput: (body: unknown) => ScimGroupInput | undefined;
+export declare const toGroupResource: (group: ScimGroup, location: string) => Record<string, unknown>;

package/dist/scim/types.d.ts

@@ -0,0 +1,54 @@
+import type { OrganizationId } from '../tenancy';
+export type ScimToken = {
+    createdAt: number;
+    hashedToken: string;
+    lastUsedAt?: number;
+    organizationId: OrganizationId;
+    tokenId: string;
+};
+export type ScimTokenStore = {
+    deleteToken: (tokenId: string) => Promise<void>;
+    findByHashedToken: (hashedToken: string) => Promise<ScimToken | undefined>;
+    listTokens: (organizationId: OrganizationId) => Promise<ScimToken[]>;
+    saveToken: (token: ScimToken) => Promise<void>;
+};
+export type ScimUser = {
+    active: boolean;
+    custom?: Record<string, unknown>;
+    displayName?: string;
+    email?: string;
+    externalId?: string;
+    familyName?: string;
+    givenName?: string;
+    id: string;
+    userName: string;
+};
+export type ScimUserInput = {
+    active: boolean;
+    custom?: Record<string, unknown>;
+    displayName?: string;
+    email?: string;
+    externalId?: string;
+    familyName?: string;
+    givenName?: string;
+    userName: string;
+};
+export type ScimGroupMember = {
+    display?: string;
+    value: string;
+};
+export type ScimGroup = {
+    displayName: string;
+    externalId?: string;
+    id: string;
+    members: ScimGroupMember[];
+};
+export type ScimGroupInput = {
+    displayName: string;
+    externalId?: string;
+    members: ScimGroupMember[];
+};
+export type ScimFilter = {
+    attribute: string;
+    value: string;
+};

package/dist/server.d.ts

@@ -0,0 +1,34 @@
+import type { AuthInstance } from './authContext';
+import type { AuthConfig } from './types';
+/**
+ * Create the complete AbsoluteJS auth application through a declaration-stable
+ * server entry point. Import this subpath in server applications so TypeScript
+ * does not need to load declarations for every optional Auth feature.
+ */
+export declare const auth: <UserType>(configuration: AuthConfig<UserType>) => Promise<AuthInstance<UserType>>;
+export { createAuthContext } from './authContext';
+export type { AuthInstance } from './authContext';
+export type { AuditSink } from './audit/types';
+export type { PortalConfig } from './portal/config';
+export type { SetupCapability, SetupSession, SetupSessionStore } from './portal/types';
+export { createSetupSession } from './portal/operations';
+export { createPostgresSetupSessionStore } from './portal/postgresSetupSessionStore';
+export { protectRoutePlugin } from './routes/protectRoute';
+export { readSessionCookie } from './session/cookieReader';
+export { requireAuthPlugin } from './routes/requireAuth';
+export type { ScimConfig } from './scim/config';
+export type { ScimFilter, ScimGroup, ScimGroupInput, ScimTokenStore, ScimUser, ScimUserInput } from './scim/types';
+export { createPostgresScimTokenStore } from './scim/postgresScimTokenStore';
+export type { AuthSessionStore } from './session/types';
+export { VerificationProviderError, type VerificationCheckInput, type VerificationCheckResult, type VerificationCheckStatus, type VerificationProvider, type VerificationProviderErrorKind, type VerificationPurpose, type VerificationStartInput, type VerificationStartResult } from './verification/types';
+export type { NodeSamlAdapterOptions } from './sso/nodeSamlAdapter';
+export { createNodeSamlAdapter } from './sso/nodeSamlAdapter';
+export type { SsoIdentity, SSOConfig } from './sso/config';
+export type { SSOConnection, SSOConnectionStore } from './sso/types';
+export { createPostgresSsoConnectionStore } from './sso/postgresSsoConnectionStore';
+export { isUserSessionId } from './typeGuards';
+export { userSessionIdTypebox } from './typebox';
+export type { AuthConfig, OAuth2ConfigurationOptions, SessionData, UnregisteredSessionData, UserSessionId } from './types';
+export { instantiateUserSession } from './utils';
+export type { OAuth2TokenResponse, ProviderOption } from 'citra';
+export { extractPropFromIdentity, isValidProviderOption, providers } from 'citra';

package/dist/server.js

@@ -5683,6 +5683,26 @@ import { Elysia as Elysia9, t as t6 } from "elysia";
 
 // src/utils.ts
 init_constants();
+
+// src/types.ts
+function isJsonValue(value) {
+  if (value === null || typeof value === "boolean" || typeof value === "string")
+    return true;
+  if (typeof value === "number")
+    return Number.isFinite(value);
+  if (Array.isArray(value))
+    return value.every(isJsonValue);
+  if (typeof value !== "object")
+    return false;
+  return Object.values(value).every(isJsonValue);
+}
+var parseJsonObject = (value) => {
+  if (!isJsonValue(value) || value === null || Array.isArray(value) || typeof value !== "object")
+    throw new TypeError("Expected a JSON object");
+  return value;
+};
+
+// src/utils.ts
 var MILLISECONDS_IN_A_SECOND2 = 1000;
 var readOptionalString = (value, property) => {
   const candidate = Reflect.get(value, property);
@@ -5842,7 +5862,7 @@ var resolveOAuthAuthorization = async ({
     oauthSubject,
     refreshToken,
     tokenType: typeof tokenType === "string" ? tokenType : undefined,
-    userIdentity
+    userIdentity: parseJsonObject(userIdentity)
   };
 };
 var parseExpiresInSeconds = (expiresIn) => {
@@ -31864,6 +31884,14 @@ __export(exports_value2, {
 // src/session/redisStore.ts
 var SESSION_SEGMENT = "sess:";
 var UNREGISTERED_SEGMENT = "unreg:";
+var jsonValueSchema = Type.Recursive((self2) => Type.Union([
+  Type.String(),
+  Type.Number(),
+  Type.Boolean(),
+  Type.Null(),
+  Type.Array(self2),
+  Type.Record(Type.String(), self2)
+]));
 var impersonatorSchema = Type.Object({
   actorEmail: Type.Optional(Type.String()),
   actorId: Type.String(),
@@ -31893,8 +31921,8 @@ var unregisteredSessionSchema = Type.Object({
   expiresAt: Type.Number(),
   oauthSubject: Type.Optional(Type.Union([Type.String(), Type.Number()])),
   refreshToken: Type.Optional(Type.String()),
-  sessionInformation: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
-  userIdentity: Type.Optional(Type.Record(Type.String(), Type.Unknown()))
+  sessionInformation: Type.Optional(Type.Record(Type.String(), jsonValueSchema)),
+  userIdentity: Type.Optional(Type.Record(Type.String(), jsonValueSchema))
 });
 var parseJson = (raw) => {
   if (raw === null)
@@ -38815,5 +38843,5 @@ export {
   VerificationProviderError
 };
 
-//# debugId=ABE5D9C482264EAE64756E2164756E21
+//# debugId=8EFCB70B3864A79464756E2164756E21
 //# sourceMappingURL=server.js.map