@teamblind/axeda-better-auth 0.0.0-stage → 0.1.0-alpha.0

package/dist/endpoints.d.ts

@@ -0,0 +1,555 @@
+import { z } from 'zod';
+import { type Actor, type AssignmentScope, type Axeda } from '@teamblind/axeda-core';
+import { type UserLookup } from './principal.js';
+/** Lo que cada endpoint exige, para la prueba que recorre todos y para la documentación. */
+export interface EndpointAccess {
+    readonly requires: string;
+    /** Alcance en el que se comprueba el permiso. */
+    readonly scope: 'own' | 'any' | 'global' | 'scope-parameter' | 'per-target';
+}
+export declare const access: (requires: string, scope: EndpointAccess["scope"]) => {
+    axeda: {
+        requires: string;
+        scope: "own" | "any" | "global" | "scope-parameter" | "per-target";
+    };
+};
+export declare const id: z.ZodString;
+export declare const cursor: z.ZodString;
+export declare const limit: z.ZodCoercedNumber<unknown>;
+export declare const scopeBody: z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodLiteral<"global">;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodEnum<{
+        company: "company";
+        business: "business";
+    }>;
+    id: z.ZodString;
+}, z.core.$strict>]>;
+export declare const scopeQuery: {
+    scopeType: z.ZodOptional<z.ZodEnum<{
+        company: "company";
+        business: "business";
+        global: "global";
+    }>>;
+    scopeId: z.ZodOptional<z.ZodString>;
+};
+export declare function scopeFromQuery(query: {
+    scopeType?: 'global' | 'company' | 'business' | undefined;
+    scopeId?: string | undefined;
+}): AssignmentScope | undefined;
+export declare const pageOf: (query: {
+    cursor?: string | undefined;
+    limit?: number | undefined;
+}) => {
+    cursor?: string;
+    limit: number;
+};
+interface SessionContext {
+    readonly context: {
+        readonly session: {
+            readonly user: {
+                readonly id: string;
+            };
+        };
+        /** Si hay `secondaryStorage`, el usuario se relee de la base de datos (ver `currentUserRow`). */
+        readonly options?: object | undefined;
+        readonly internalAdapter?: UserLookup | undefined;
+    };
+    readonly headers?: Headers | undefined;
+    readonly request?: Request | undefined;
+}
+/**
+ * Quien actúa, a partir de la sesión: el `Principal` (ver `principalFromUser`) más los datos de la
+ * petición para la auditoría.
+ */
+export declare function actorFromSession(ctx: SessionContext): Promise<Actor>;
+export type CoreProvider = () => Axeda;
+/** Ejecuta un caso de uso con el actor de la sesión y traduce sus errores a respuestas HTTP. */
+export declare function run<T>(ctx: SessionContext, core: CoreProvider, work: (axeda: Axeda, actor: Actor) => Promise<T>): Promise<T>;
+/**
+ * Los endpoints del plugin. Todos exigen sesión (`sessionMiddleware`) y declaran su permiso en
+ * `metadata.axeda`; el permiso lo impone el caso de uso, no el endpoint. Los endpoints de Better
+ * Auth solo admiten GET y POST.
+ */
+export declare function createEndpoints(core: CoreProvider): {
+    axedaMe: import("better-call").StrictEndpoint<"/axeda/me", {
+        method: "GET";
+        use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+            session: {
+                session: Record<string, any> & {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    userId: string;
+                    expiresAt: Date;
+                    token: string;
+                    ipAddress?: string | null | undefined;
+                    userAgent?: string | null | undefined;
+                };
+                user: Record<string, any> & {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                };
+            };
+        }>>[];
+        metadata: {
+            axeda: {
+                requires: string;
+                scope: "own" | "any" | "global" | "scope-parameter" | "per-target";
+            };
+        };
+    }, {
+        userId: string;
+        twoFactorEnabled: boolean;
+        globalPermissions: string[];
+        assignments: import("./dto.js").AssignmentDto[];
+    }>;
+    axedaPermissionList: import("better-call").StrictEndpoint<"/axeda/permission/list", {
+        method: "GET";
+        use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+            session: {
+                session: Record<string, any> & {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    userId: string;
+                    expiresAt: Date;
+                    token: string;
+                    ipAddress?: string | null | undefined;
+                    userAgent?: string | null | undefined;
+                };
+                user: Record<string, any> & {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                };
+            };
+        }>>[];
+        metadata: {
+            axeda: {
+                requires: string;
+                scope: "own" | "any" | "global" | "scope-parameter" | "per-target";
+            };
+        };
+    }, {
+        permissions: string[];
+    }>;
+    axedaRoleList: import("better-call").StrictEndpoint<"/axeda/role/list", {
+        method: "GET";
+        use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+            session: {
+                session: Record<string, any> & {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    userId: string;
+                    expiresAt: Date;
+                    token: string;
+                    ipAddress?: string | null | undefined;
+                    userAgent?: string | null | undefined;
+                };
+                user: Record<string, any> & {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                };
+            };
+        }>>[];
+        query: z.ZodObject<{
+            cursor: z.ZodOptional<z.ZodString>;
+            limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+        }, z.core.$strict>;
+        metadata: {
+            axeda: {
+                requires: string;
+                scope: "own" | "any" | "global" | "scope-parameter" | "per-target";
+            };
+        };
+    }, {
+        items: import("./dto.js").RoleDto[];
+        nextCursor: string | null;
+    }>;
+    axedaRoleGet: import("better-call").StrictEndpoint<"/axeda/role/get", {
+        method: "GET";
+        use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+            session: {
+                session: Record<string, any> & {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    userId: string;
+                    expiresAt: Date;
+                    token: string;
+                    ipAddress?: string | null | undefined;
+                    userAgent?: string | null | undefined;
+                };
+                user: Record<string, any> & {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                };
+            };
+        }>>[];
+        query: z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strict>;
+        metadata: {
+            axeda: {
+                requires: string;
+                scope: "own" | "any" | "global" | "scope-parameter" | "per-target";
+            };
+        };
+    }, import("./dto.js").RoleDto>;
+    axedaRoleCreate: import("better-call").StrictEndpoint<"/axeda/role/create", {
+        method: "POST";
+        use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+            session: {
+                session: Record<string, any> & {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    userId: string;
+                    expiresAt: Date;
+                    token: string;
+                    ipAddress?: string | null | undefined;
+                    userAgent?: string | null | undefined;
+                };
+                user: Record<string, any> & {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                };
+            };
+        }>>[];
+        body: z.ZodObject<{
+            key: z.ZodString;
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            permissions: z.ZodArray<z.ZodString>;
+            requireMfa: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>;
+        metadata: {
+            axeda: {
+                requires: string;
+                scope: "own" | "any" | "global" | "scope-parameter" | "per-target";
+            };
+        };
+    }, import("./dto.js").RoleDto>;
+    axedaRoleUpdate: import("better-call").StrictEndpoint<"/axeda/role/update", {
+        method: "POST";
+        use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+            session: {
+                session: Record<string, any> & {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    userId: string;
+                    expiresAt: Date;
+                    token: string;
+                    ipAddress?: string | null | undefined;
+                    userAgent?: string | null | undefined;
+                };
+                user: Record<string, any> & {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                };
+            };
+        }>>[];
+        body: z.ZodObject<{
+            id: z.ZodString;
+            version: z.ZodNumber;
+            name: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            permissions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            requireMfa: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>;
+        metadata: {
+            axeda: {
+                requires: string;
+                scope: "own" | "any" | "global" | "scope-parameter" | "per-target";
+            };
+        };
+    }, import("./dto.js").RoleDto>;
+    axedaRoleSetStatus: import("better-call").StrictEndpoint<"/axeda/role/set-status", {
+        method: "POST";
+        use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+            session: {
+                session: Record<string, any> & {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    userId: string;
+                    expiresAt: Date;
+                    token: string;
+                    ipAddress?: string | null | undefined;
+                    userAgent?: string | null | undefined;
+                };
+                user: Record<string, any> & {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                };
+            };
+        }>>[];
+        body: z.ZodObject<{
+            id: z.ZodString;
+            version: z.ZodNumber;
+            status: z.ZodEnum<{
+                active: "active";
+                inactive: "inactive";
+            }>;
+        }, z.core.$strict>;
+        metadata: {
+            axeda: {
+                requires: string;
+                scope: "own" | "any" | "global" | "scope-parameter" | "per-target";
+            };
+        };
+    }, import("./dto.js").RoleDto>;
+    axedaRoleDelete: import("better-call").StrictEndpoint<"/axeda/role/delete", {
+        method: "POST";
+        use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+            session: {
+                session: Record<string, any> & {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    userId: string;
+                    expiresAt: Date;
+                    token: string;
+                    ipAddress?: string | null | undefined;
+                    userAgent?: string | null | undefined;
+                };
+                user: Record<string, any> & {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                };
+            };
+        }>>[];
+        body: z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strict>;
+        metadata: {
+            axeda: {
+                requires: string;
+                scope: "own" | "any" | "global" | "scope-parameter" | "per-target";
+            };
+        };
+    }, {
+        deleted: true;
+    }>;
+    axedaAssignmentList: import("better-call").StrictEndpoint<"/axeda/assignment/list", {
+        method: "GET";
+        use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+            session: {
+                session: Record<string, any> & {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    userId: string;
+                    expiresAt: Date;
+                    token: string;
+                    ipAddress?: string | null | undefined;
+                    userAgent?: string | null | undefined;
+                };
+                user: Record<string, any> & {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                };
+            };
+        }>>[];
+        query: z.ZodObject<{
+            cursor: z.ZodOptional<z.ZodString>;
+            limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+            scopeType: z.ZodOptional<z.ZodEnum<{
+                company: "company";
+                business: "business";
+                global: "global";
+            }>>;
+            scopeId: z.ZodOptional<z.ZodString>;
+            userId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        metadata: {
+            axeda: {
+                requires: string;
+                scope: "own" | "any" | "global" | "scope-parameter" | "per-target";
+            };
+        };
+    }, {
+        items: import("./dto.js").AssignmentDto[];
+        nextCursor: string | null;
+    }>;
+    axedaAssignmentCreate: import("better-call").StrictEndpoint<"/axeda/assignment/create", {
+        method: "POST";
+        use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+            session: {
+                session: Record<string, any> & {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    userId: string;
+                    expiresAt: Date;
+                    token: string;
+                    ipAddress?: string | null | undefined;
+                    userAgent?: string | null | undefined;
+                };
+                user: Record<string, any> & {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                };
+            };
+        }>>[];
+        body: z.ZodObject<{
+            userId: z.ZodString;
+            roleId: z.ZodString;
+            scope: z.ZodUnion<readonly [z.ZodObject<{
+                type: z.ZodLiteral<"global">;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodEnum<{
+                    company: "company";
+                    business: "business";
+                }>;
+                id: z.ZodString;
+            }, z.core.$strict>]>;
+            expiresAt: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
+        }, z.core.$strict>;
+        metadata: {
+            axeda: {
+                requires: string;
+                scope: "own" | "any" | "global" | "scope-parameter" | "per-target";
+            };
+        };
+    }, import("./dto.js").AssignmentDto>;
+    axedaAssignmentRevoke: import("better-call").StrictEndpoint<"/axeda/assignment/revoke", {
+        method: "POST";
+        use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+            session: {
+                session: Record<string, any> & {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    userId: string;
+                    expiresAt: Date;
+                    token: string;
+                    ipAddress?: string | null | undefined;
+                    userAgent?: string | null | undefined;
+                };
+                user: Record<string, any> & {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                };
+            };
+        }>>[];
+        body: z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strict>;
+        metadata: {
+            axeda: {
+                requires: string;
+                scope: "own" | "any" | "global" | "scope-parameter" | "per-target";
+            };
+        };
+    }, {
+        revoked: true;
+    }>;
+    axedaAuditList: import("better-call").StrictEndpoint<"/axeda/audit/list", {
+        method: "GET";
+        use: import("better-call").Middleware<import("better-call").MiddlewareOptions, (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+            session: {
+                session: Record<string, any> & {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    userId: string;
+                    expiresAt: Date;
+                    token: string;
+                    ipAddress?: string | null | undefined;
+                    userAgent?: string | null | undefined;
+                };
+                user: Record<string, any> & {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                };
+            };
+        }>>[];
+        query: z.ZodObject<{
+            cursor: z.ZodOptional<z.ZodString>;
+            limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+            scopeType: z.ZodOptional<z.ZodEnum<{
+                company: "company";
+                business: "business";
+                global: "global";
+            }>>;
+            scopeId: z.ZodOptional<z.ZodString>;
+            actorId: z.ZodOptional<z.ZodString>;
+            action: z.ZodOptional<z.ZodString>;
+            targetType: z.ZodOptional<z.ZodString>;
+            targetId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        metadata: {
+            axeda: {
+                requires: string;
+                scope: "own" | "any" | "global" | "scope-parameter" | "per-target";
+            };
+        };
+    }, {
+        items: import("./dto.js").AuditEventDto[];
+        nextCursor: string | null;
+    }>;
+};
+export {};