@velajs/better-auth 0.6.0 → 0.6.1

package/package.json

@@ -1,8 +1,35 @@
 {
   "name": "@velajs/better-auth",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "better-auth integration for the Vela framework",
+  "keywords": [
+    "auth",
+    "authentication",
+    "better-auth",
+    "edge",
+    "framework",
+    "oauth",
+    "session",
+    "vela"
+  ],
+  "homepage": "https://github.com/velajs/better-auth#readme",
+  "bugs": {
+    "url": "https://github.com/velajs/better-auth/issues"
+  },
+  "license": "MIT",
+  "author": "ksh",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/velajs/better-auth.git"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
   "type": "module",
+  "sideEffects": false,
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
@@ -15,55 +42,45 @@
       "import": "./dist/testing/index.js"
     }
   },
-  "files": [
-    "dist",
-    "README.md",
-    "LICENSE",
-    "CHANGELOG.md"
-  ],
-  "sideEffects": false,
-  "keywords": [
-    "vela",
-    "better-auth",
-    "auth",
-    "authentication",
-    "session",
-    "oauth",
-    "edge",
-    "framework"
-  ],
-  "author": "ksh",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/velajs/better-auth.git"
-  },
-  "homepage": "https://github.com/velajs/better-auth#readme",
-  "bugs": {
-    "url": "https://github.com/velajs/better-auth/issues"
-  },
-  "engines": {
-    "node": ">=20"
-  },
-  "peerDependencies": {
-    "@velajs/vela": ">=1.11.0",
-    "better-auth": ">=1.2.0",
-    "hono": ">=4"
+  "dependencies": {
+    "@velajs/authz": "^1.0.0"
   },
   "devDependencies": {
-    "@swc/cli": "^0.8.1",
-    "@swc/core": "^1.15.41",
+    "@arethetypeswrong/cli": "^0.18.5",
+    "@changesets/cli": "^2.31.0",
+    "@swc/core": "^1.15.43",
     "@velajs/testing": "^0.4.0",
     "@velajs/vela": "^1.12.0",
     "better-auth": "^1.6.20",
     "hono": "^4.12.26",
-    "typescript": "^6.0.3",
+    "oxfmt": "^0.58.0",
+    "oxlint": "^1.73.0",
+    "publint": "^0.3.21",
+    "tsdown": "^0.22.4",
+    "typescript": "^7.0.2",
     "unplugin-swc": "^1.5.9",
-    "vitest": "^4.1.9"
+    "vitest": "^4.1.10"
+  },
+  "peerDependencies": {
+    "@velajs/vela": ">=1.11.0",
+    "better-auth": ">=1.2.0",
+    "hono": ">=4"
+  },
+  "engines": {
+    "node": ">=24"
   },
   "scripts": {
-    "build": "rm -rf dist && swc src -d dist --strip-leading-paths && tsc --emitDeclarationOnly",
+    "build": "tsdown",
     "test": "vitest run",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "lint": "oxlint .",
+    "format": "oxfmt .",
+    "format:check": "oxfmt --check .",
+    "publint": "publint",
+    "attw": "attw --pack . --profile esm-only",
+    "changeset": "changeset",
+    "version-packages": "changeset version",
+    "release": "pnpm build && changeset publish",
+    "verify": "pnpm lint && pnpm format:check && pnpm build && pnpm typecheck && pnpm test && pnpm publint && pnpm attw"
   }
 }

package/dist/better-auth.controller.d.ts

@@ -1,21 +0,0 @@
-import { type Type } from '@velajs/vela';
-/**
- * Build a catch-all controller that mounts better-auth's handler at `basePath`
- * (default `/api/auth`). This is a factory because vela reads a controller's
- * route off the class at decoration time, so a custom base path needs its own
- * decorated class — the path can't be parametrized on a single shared class.
- *
- * Two base paths to keep consistent:
- * - this `basePath` is RELATIVE to vela's `globalPrefix` (always prepended);
- * - better-auth routes against its OWN absolute `basePath` (the one you pass to
- *   `betterAuth({ basePath })`), which must equal `globalPrefix + basePath`.
- *
- * Both default to `/api/auth`, so the no-prefix / no-config case just works.
- */
-export declare function createBetterAuthCatchallController(basePath?: string): Type;
-/**
- * Default-path (`/api/auth`) catch-all controller. Retained for back-compat;
- * `BetterAuthModule` now mounts {@link createBetterAuthCatchallController} with
- * the configured `basePath`. Prefer the factory for a custom base path.
- */
-export declare const BetterAuthCatchallController: Type;

package/dist/better-auth.controller.js

@@ -1,68 +0,0 @@
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-import { All, Controller, Inject, Injectable, Req } from "@velajs/vela";
-import { BetterAuthService } from "./better-auth.service.js";
-import { Public } from "./decorators/public.decorator.js";
-/**
- * Build a catch-all controller that mounts better-auth's handler at `basePath`
- * (default `/api/auth`). This is a factory because vela reads a controller's
- * route off the class at decoration time, so a custom base path needs its own
- * decorated class — the path can't be parametrized on a single shared class.
- *
- * Two base paths to keep consistent:
- * - this `basePath` is RELATIVE to vela's `globalPrefix` (always prepended);
- * - better-auth routes against its OWN absolute `basePath` (the one you pass to
- *   `betterAuth({ basePath })`), which must equal `globalPrefix + basePath`.
- *
- * Both default to `/api/auth`, so the no-prefix / no-config case just works.
- */ export function createBetterAuthCatchallController(basePath = '/api/auth') {
-    let BetterAuthCatchallController = class BetterAuthCatchallController {
-        auth;
-        // Inject the service — its `.handler` getter triggers lazy construction
-        // of the underlying betterAuth() instance on first access, AFTER any
-        // runtime adapter middleware (Cloudflare env capture) has run.
-        constructor(auth){
-            this.auth = auth;
-        }
-        async handle(c) {
-            return this.auth.handler(c.req.raw);
-        }
-    };
-    _ts_decorate([
-        All('/*'),
-        _ts_param(0, Req()),
-        _ts_metadata("design:type", Function),
-        _ts_metadata("design:paramtypes", [
-            typeof Context === "undefined" ? Object : Context
-        ]),
-        _ts_metadata("design:returntype", Promise)
-    ], BetterAuthCatchallController.prototype, "handle", null);
-    BetterAuthCatchallController = _ts_decorate([
-        Public(true),
-        Controller(basePath),
-        Injectable(),
-        _ts_param(0, Inject(BetterAuthService)),
-        _ts_metadata("design:type", Function),
-        _ts_metadata("design:paramtypes", [
-            typeof BetterAuthService === "undefined" ? Object : BetterAuthService
-        ])
-    ], BetterAuthCatchallController);
-    return BetterAuthCatchallController;
-}
-/**
- * Default-path (`/api/auth`) catch-all controller. Retained for back-compat;
- * `BetterAuthModule` now mounts {@link createBetterAuthCatchallController} with
- * the configured `basePath`. Prefer the factory for a custom base path.
- */ export const BetterAuthCatchallController = createBetterAuthCatchallController();

package/dist/better-auth.module.d.ts

@@ -1,52 +0,0 @@
-import { type DynamicModule, type InferTokens, type Token } from '@velajs/vela';
-import type { BetterAuthInstance, BetterAuthModuleOptions } from './better-auth.types';
-/**
- * Options for {@link BetterAuthModule.forRootAsync}.
- *
- * The `Inject` type parameter captures the literal `inject` tuple at the call
- * site (via `const` inference) so `useFactory` parameters are typed from the
- * inject array, position-by-position — no `as const`, no `(...deps: any[])`:
- *
- * ```ts
- * BetterAuthModule.forRootAsync({
- *   inject: [D1Service, ConfigService],   // captured as readonly tuple
- *   useFactory: (d1, config) =>            // d1: D1Service, config: ConfigService
- *     betterAuth({ database: drizzleAdapter(drizzle(d1.database), ...) }),
- * });
- * ```
- */
-interface ForRootAsyncOptions<Inject extends readonly Token<unknown>[] = readonly Token<unknown>[]> {
-    inject?: Inject;
-    imports?: DynamicModule['imports'];
-    useFactory: (...deps: InferTokens<Inject>) => BetterAuthInstance;
-    isGlobal?: boolean;
-    mountHandler?: boolean;
-    basePath?: string;
-    defaultPolicy?: 'deny' | 'allow';
-    key?: string;
-}
-export declare class BetterAuthModule {
-    /**
-     * Synchronous registration. The auth instance is constructed by the consumer
-     * at module-load time and passed in directly. Use this when the inputs to
-     * `betterAuth({...})` are available at startup (Node apps with a static DB
-     * connection, in-memory adapters, etc.).
-     */
-    static forRoot(options: BetterAuthModuleOptions & {
-        isGlobal?: boolean;
-        key?: string;
-    }): DynamicModule;
-    /**
-     * Deferred / DI-driven registration. The user factory runs **lazily**, on the
-     * first time anything reads `BetterAuthService.auth` (or `.api` / `.handler`).
-     * In normal request handling that's `AuthGuard.canActivate` or the catch-all
-     * controller's `.handle`. At module load the factory does NOT run — it's only
-     * captured behind {@link lazyProvider}'s memoized thunk. This is what makes
-     * Cloudflare bindings (D1, KV, R2) work: the binding isn't ready at boot, but
-     * it IS by the time a request flows through and the guard / catch-all reads
-     * the service. Inject deps resolve at module load (cheap BindingRef wrappers);
-     * their *values* are read at first auth use, inside your factory body.
-     */
-    static forRootAsync<const Inject extends readonly Token<unknown>[] = readonly Token<unknown>[]>(options: ForRootAsyncOptions<Inject>): DynamicModule;
-}
-export {};

package/dist/better-auth.module.js

@@ -1,138 +0,0 @@
-import { defineModule, lazyProvider, provideGlobal, stableHash } from "@velajs/vela";
-import { createBetterAuthCatchallController } from "./better-auth.controller.js";
-import { BetterAuthService, BETTER_AUTH_BUILDER } from "./better-auth.service.js";
-import { BETTER_AUTH_OPTIONS } from "./better-auth.tokens.js";
-import { AuthGuard } from "./guards/auth.guard.js";
-import { RolesGuard } from "./guards/roles.guard.js";
-const DEFAULT_BASE_PATH = '/api/auth';
-function normalize(options) {
-    return {
-        basePath: options.basePath ?? DEFAULT_BASE_PATH,
-        isGlobal: options.isGlobal ?? false,
-        defaultPolicy: options.defaultPolicy ?? 'deny',
-        mountHandler: options.mountHandler ?? true
-    };
-}
-/** Providers, controllers, and exports shared by both entry points. */ function commonContributions(n) {
-    return {
-        providers: [
-            BetterAuthService,
-            AuthGuard,
-            RolesGuard
-        ],
-        controllers: n.mountHandler ? [
-            createBetterAuthCatchallController(n.basePath)
-        ] : [],
-        exports: [
-            BetterAuthService,
-            BETTER_AUTH_OPTIONS,
-            AuthGuard,
-            RolesGuard
-        ]
-    };
-}
-/**
- * The blessed engine generates `forRoot`. `setup` runs once per instance at
- * call time: it re-provides {@link BETTER_AUTH_OPTIONS} with defaults applied,
- * derives the auth builder from those options, mounts the catch-all controller,
- * and — via the `global:` slot — registers the app-wide guard when `isGlobal`.
- *
- * `isGlobal` here means "apply AuthGuard app-wide", NOT "make this a global
- * module", so the default `isGlobal → global: true` extras transform is
- * replaced with identity; the flag reaches `setup` through the options bag.
- */ const authModuleHost = defineModule({
-    name: 'BetterAuth',
-    optionsToken: BETTER_AUTH_OPTIONS,
-    transform: (definition)=>definition,
-    // The auth instance is a stateful value — key off the structural subset only.
-    key: (options)=>stableHash(normalize(options)),
-    setup: ({ OPTIONS, options })=>{
-        const n = normalize(options);
-        const common = commonContributions(n);
-        const auth = options.auth;
-        return {
-            providers: [
-                // Override the auto-provided raw bag with the normalized shape so
-                // BETTER_AUTH_OPTIONS consumers always see defaults + the auth instance.
-                {
-                    provide: OPTIONS,
-                    useValue: {
-                        ...n,
-                        auth
-                    }
-                },
-                // Eager auth: the builder hands back the instance the caller passed in.
-                lazyProvider({
-                    provide: BETTER_AUTH_BUILDER,
-                    inject: [
-                        OPTIONS
-                    ],
-                    useFactory: (o)=>o.auth
-                }),
-                ...common.providers
-            ],
-            controllers: common.controllers,
-            exports: common.exports,
-            global: n.isGlobal ? {
-                guards: [
-                    AuthGuard
-                ]
-            } : undefined
-        };
-    }
-});
-export class BetterAuthModule {
-    /**
-   * Synchronous registration. The auth instance is constructed by the consumer
-   * at module-load time and passed in directly. Use this when the inputs to
-   * `betterAuth({...})` are available at startup (Node apps with a static DB
-   * connection, in-memory adapters, etc.).
-   */ static forRoot(options) {
-        // Delegate to the generated static, then rebrand the module identity so the
-        // public `BetterAuthModule` class is the one registered (consistent with
-        // `forRootAsync` and better diagnostics).
-        return {
-            ...authModuleHost.ConfigurableModuleClass.forRoot(options),
-            module: BetterAuthModule
-        };
-    }
-    /**
-   * Deferred / DI-driven registration. The user factory runs **lazily**, on the
-   * first time anything reads `BetterAuthService.auth` (or `.api` / `.handler`).
-   * In normal request handling that's `AuthGuard.canActivate` or the catch-all
-   * controller's `.handle`. At module load the factory does NOT run — it's only
-   * captured behind {@link lazyProvider}'s memoized thunk. This is what makes
-   * Cloudflare bindings (D1, KV, R2) work: the binding isn't ready at boot, but
-   * it IS by the time a request flows through and the guard / catch-all reads
-   * the service. Inject deps resolve at module load (cheap BindingRef wrappers);
-   * their *values* are read at first auth use, inside your factory body.
-   */ static forRootAsync(options) {
-        const n = normalize(options);
-        const common = commonContributions(n);
-        return {
-            module: BetterAuthModule,
-            key: options.key ?? stableHash({
-                ...n,
-                inject: options.inject
-            }),
-            imports: options.imports ?? [],
-            providers: [
-                {
-                    provide: BETTER_AUTH_OPTIONS,
-                    useValue: n
-                },
-                // The deferred auth builder: `lazyProvider` wraps the user factory in a
-                // memoized thunk, replacing the hand-rolled `(...deps) => () => f(...deps)`.
-                lazyProvider({
-                    provide: BETTER_AUTH_BUILDER,
-                    inject: options.inject,
-                    useFactory: options.useFactory
-                }),
-                ...common.providers,
-                ...n.isGlobal ? provideGlobal('guard', AuthGuard) : []
-            ],
-            controllers: common.controllers,
-            exports: common.exports
-        };
-    }
-}

package/dist/better-auth.service.d.ts

@@ -1,42 +0,0 @@
-import { InjectionToken } from '@velajs/vela';
-import type { BetterAuthInstance } from './better-auth.types';
-/**
- * Internal token holding the auth-construction closure with its inject deps
- * closed over. Resolves cheaply at module load (just captures references);
- * the inner call happens lazily on first auth use (see `BetterAuthService`).
- *
- * Not exported from the public surface — only the service consumes it.
- */
-export declare const BETTER_AUTH_BUILDER: InjectionToken<() => BetterAuthInstance>;
-/**
- * The single injectable consumers reach for to interact with better-auth.
- * Wraps the underlying `betterAuth({...})` instance with lazy construction:
- *
- * - `forRoot({ auth })` — the builder returns the eagerly-provided instance,
- *   so the first `.auth` / `.api` / `.handler` access is effectively a
- *   read-and-cache.
- * - `forRootAsync({ inject, useFactory })` — the builder wraps the user's
- *   factory + inject deps. First access triggers `useFactory(...deps)`. This
- *   is what makes Cloudflare D1/KV bindings work: at module load the factory
- *   doesn't run; on first request (when AuthGuard or the catch-all calls
- *   `service.api` / `service.handler`), the bindings are populated and the
- *   factory can read them safely.
- *
- * Used directly by AuthGuard and the catch-all controller. Consumers in
- * application code inject the same way: `@Inject(BetterAuthService)`.
- */
-export declare class BetterAuthService {
-    private readonly build;
-    private cached;
-    constructor(build: () => BetterAuthInstance);
-    /**
-     * The underlying better-auth instance. Constructed once on first access.
-     * Safe to call from any request-time code path (guards, controllers,
-     * services invoked from handlers).
-     */
-    get auth(): BetterAuthInstance;
-    /** Convenience accessor — equivalent to `service.auth.api`. */
-    get api(): BetterAuthInstance['api'];
-    /** Convenience accessor — equivalent to `service.auth.handler`. */
-    get handler(): BetterAuthInstance['handler'];
-}

package/dist/better-auth.service.js

@@ -1,51 +0,0 @@
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-import { Inject, Injectable, InjectionToken } from "@velajs/vela";
-/**
- * Internal token holding the auth-construction closure with its inject deps
- * closed over. Resolves cheaply at module load (just captures references);
- * the inner call happens lazily on first auth use (see `BetterAuthService`).
- *
- * Not exported from the public surface — only the service consumes it.
- */ export const BETTER_AUTH_BUILDER = new InjectionToken('vela.better-auth.Builder');
-export class BetterAuthService {
-    build;
-    cached;
-    constructor(build){
-        this.build = build;
-    }
-    /**
-   * The underlying better-auth instance. Constructed once on first access.
-   * Safe to call from any request-time code path (guards, controllers,
-   * services invoked from handlers).
-   */ get auth() {
-        if (!this.cached) this.cached = this.build();
-        return this.cached;
-    }
-    /** Convenience accessor — equivalent to `service.auth.api`. */ get api() {
-        return this.auth.api;
-    }
-    /** Convenience accessor — equivalent to `service.auth.handler`. */ get handler() {
-        return this.auth.handler;
-    }
-}
-BetterAuthService = _ts_decorate([
-    Injectable(),
-    _ts_param(0, Inject(BETTER_AUTH_BUILDER)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        Function
-    ])
-], BetterAuthService);

package/dist/better-auth.tokens.d.ts

@@ -1,5 +0,0 @@
-import { InjectionToken } from '@velajs/vela';
-import type { BetterAuthModuleOptions } from './better-auth.types';
-export declare const BETTER_AUTH_OPTIONS: InjectionToken<BetterAuthModuleOptions>;
-export declare const AUTH_USER_KEY: unique symbol;
-export declare const AUTH_SESSION_KEY: unique symbol;

package/dist/better-auth.tokens.js

@@ -1,4 +0,0 @@
-import { InjectionToken } from "@velajs/vela";
-export const BETTER_AUTH_OPTIONS = new InjectionToken('vela.BetterAuthOptions');
-export const AUTH_USER_KEY = Symbol.for('vela.better-auth.user');
-export const AUTH_SESSION_KEY = Symbol.for('vela.better-auth.session');

package/dist/better-auth.types.d.ts

@@ -1,11 +0,0 @@
-import type { Auth, Session as BASession, User as BAUser } from 'better-auth';
-export type BetterAuthInstance = Auth<any>;
-export interface BetterAuthModuleOptions {
-    auth: BetterAuthInstance;
-    basePath?: string;
-    isGlobal?: boolean;
-    defaultPolicy?: 'deny' | 'allow';
-    mountHandler?: boolean;
-}
-export type User = BAUser;
-export type Session = BASession;

package/dist/better-auth.types.js

@@ -1 +0,0 @@
-export { };

package/dist/decorators/current-session.decorator.d.ts

@@ -1 +0,0 @@
-export declare const CurrentSession: (data?: unknown, ...pipes: import("@velajs/vela").PipeType[]) => ParameterDecorator;

package/dist/decorators/current-session.decorator.js

@@ -1,7 +0,0 @@
-import { createLazyParamDecorator, REQUEST_CONTEXT } from "@velajs/vela";
-import { AUTH_SESSION_KEY } from "../better-auth.tokens.js";
-export const CurrentSession = createLazyParamDecorator((_data, ctx)=>{
-    const honoCtx = ctx.getContext();
-    const reqCtx = honoCtx.get('container').resolve(REQUEST_CONTEXT);
-    return reqCtx.get(AUTH_SESSION_KEY);
-});

package/dist/decorators/current-user.decorator.d.ts

@@ -1 +0,0 @@
-export declare const CurrentUser: (data?: unknown, ...pipes: import("@velajs/vela").PipeType[]) => ParameterDecorator;

package/dist/decorators/current-user.decorator.js

@@ -1,7 +0,0 @@
-import { createLazyParamDecorator, REQUEST_CONTEXT } from "@velajs/vela";
-import { AUTH_USER_KEY } from "../better-auth.tokens.js";
-export const CurrentUser = createLazyParamDecorator((_data, ctx)=>{
-    const honoCtx = ctx.getContext();
-    const reqCtx = honoCtx.get('container').resolve(REQUEST_CONTEXT);
-    return reqCtx.get(AUTH_USER_KEY);
-});

package/dist/decorators/optional-auth.decorator.d.ts

@@ -1,2 +0,0 @@
-export declare const OptionalAuth: import("@velajs/vela").ReflectableDecorator<boolean>;
-export declare const OPTIONAL_AUTH_KEY: string;

package/dist/decorators/optional-auth.decorator.js

@@ -1,5 +0,0 @@
-import { Reflector } from "@velajs/vela";
-export const OptionalAuth = Reflector.createDecorator({
-    key: 'vela.auth.optional'
-});
-export const OPTIONAL_AUTH_KEY = OptionalAuth.KEY;

package/dist/decorators/public.decorator.d.ts

@@ -1,2 +0,0 @@
-export declare const Public: import("@velajs/vela").ReflectableDecorator<boolean>;
-export declare const PUBLIC_KEY: string;

package/dist/decorators/public.decorator.js

@@ -1,5 +0,0 @@
-import { Reflector } from "@velajs/vela";
-export const Public = Reflector.createDecorator({
-    key: 'vela.auth.public'
-});
-export const PUBLIC_KEY = Public.KEY;

package/dist/decorators/roles.decorator.d.ts

@@ -1,2 +0,0 @@
-export declare const Roles: import("@velajs/vela").ReflectableDecorator<string[]>;
-export declare const ROLES_KEY: string;

package/dist/decorators/roles.decorator.js

@@ -1,5 +0,0 @@
-import { Reflector } from "@velajs/vela";
-export const Roles = Reflector.createDecorator({
-    key: 'vela.auth.roles'
-});
-export const ROLES_KEY = Roles.KEY;

package/dist/guards/auth.guard.d.ts

@@ -1,10 +0,0 @@
-import { type CanActivate, type ExecutionContext } from '@velajs/vela';
-import { BetterAuthService } from '../better-auth.service';
-import type { BetterAuthModuleOptions } from '../better-auth.types';
-export declare class AuthGuard implements CanActivate {
-    private readonly auth;
-    private readonly opts;
-    private readonly reflector;
-    constructor(auth: BetterAuthService, opts: BetterAuthModuleOptions);
-    canActivate(context: ExecutionContext): Promise<boolean>;
-}