@stratal/framework 0.0.13 → 0.0.14

package/dist/factory/index.d.mts

@@ -0,0 +1,99 @@
+import { O as DatabaseService } from "../index-Dlg8mNjq.mjs";
+import { Faker } from "@faker-js/faker";
+
+//#region src/factory/factory.d.ts
+/**
+ * Factory
+ *
+ * Abstract base class for creating test data.
+ * Integrates with Faker.js for data generation.
+ *
+ * @example Define a factory
+ * ```typescript
+ * import { Factory } from '@stratal/framework/factory'
+ * import type { User, UserCreateInput } from '@your-app/db'
+ *
+ * export class UserFactory extends Factory<User, UserCreateInput> {
+ *   protected model = 'user'
+ *
+ *   protected definition(): UserCreateInput {
+ *     return {
+ *       email: this.faker.internet.email(),
+ *       firstName: this.faker.person.firstName(),
+ *       lastName: this.faker.person.lastName(),
+ *       emailVerified: true,
+ *     }
+ *   }
+ *
+ *   admin() {
+ *     return this.state(attrs => ({ ...attrs, role: 'admin' }))
+ *   }
+ * }
+ * ```
+ *
+ * @example Usage
+ * ```typescript
+ * const user = await new UserFactory().create(ctx.db)
+ * const admin = await new UserFactory().admin().create(ctx.db)
+ * const users = await new UserFactory().count(10).createManyAndReturn(ctx.db)
+ * ```
+ */
+declare abstract class Factory<TModel, TCreateInput> {
+  protected readonly faker: Faker;
+  protected abstract model: string;
+  protected abstract definition(): TCreateInput;
+  private states;
+  private _count;
+  state(modifier: (attrs: TCreateInput) => Partial<TCreateInput>): this;
+  count(n: number): this;
+  make(): TCreateInput;
+  makeMany(count?: number): TCreateInput[];
+  create(db: DatabaseService): Promise<TModel>;
+  createMany(db: DatabaseService, count?: number): Promise<{
+    count: number;
+  }>;
+  createManyAndReturn(db: DatabaseService, count?: number): Promise<TModel[]>;
+  protected clone(): this;
+}
+//#endregion
+//#region src/factory/sequence.d.ts
+/**
+ * Sequence
+ *
+ * Auto-incrementing sequence generator for creating unique values.
+ *
+ * @example Basic usage
+ * ```typescript
+ * const emailSeq = new Sequence((n) => `user${n}@example.com`)
+ *
+ * emailSeq.next() // 'user1@example.com'
+ * emailSeq.next() // 'user2@example.com'
+ * emailSeq.reset()
+ * emailSeq.next() // 'user1@example.com'
+ * ```
+ *
+ * @example With factory
+ * ```typescript
+ * const orderSeq = new Sequence((n) => `ORD-${String(n).padStart(6, '0')}`)
+ *
+ * export class OrderFactory extends Factory<Order, OrderCreateInput> {
+ *   protected definition() {
+ *     return {
+ *       orderNumber: orderSeq.next(),
+ *       // ...
+ *     }
+ *   }
+ * }
+ * ```
+ */
+declare class Sequence<T = number> {
+  private readonly generator?;
+  private current;
+  constructor(generator?: ((n: number) => T) | undefined);
+  next(): T;
+  peek(): T;
+  reset(): void;
+}
+//#endregion
+export { Factory, Sequence };
+//# sourceMappingURL=index.d.mts.map

package/dist/factory/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/factory/factory.ts","../../src/factory/sequence.ts"],"mappings":";;;;;;AAuCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAAsB,OAAA;EAAA,mBACD,KAAA,EAAO,KAAA;EAAA,mBACP,KAAA;EAAA,mBACA,UAAA,CAAA,GAAc,YAAA;EAAA,QAEzB,MAAA;EAAA,QACA,MAAA;EAER,KAAA,CAAM,QAAA,GAAW,KAAA,EAAO,YAAA,KAAiB,OAAA,CAAQ,YAAA;EAMjD,KAAA,CAAM,CAAA;EAMN,IAAA,CAAA,GAAQ,YAAA;EAQR,QAAA,CAAS,KAAA,YAAiB,YAAA;EAKpB,MAAA,CAAO,EAAA,EAAI,eAAA,GAAkB,OAAA,CAAQ,MAAA;EAMrC,UAAA,CAAW,EAAA,EAAI,eAAA,EAAiB,KAAA,YAAiB,OAAA;IAAU,KAAA;EAAA;EAM3D,mBAAA,CAAoB,EAAA,EAAI,eAAA,EAAiB,KAAA,YAAiB,OAAA,CAAQ,MAAA;EAAA,UAM9D,KAAA,CAAA;AAAA;;;;;;;AAnDZ;;;;;;;;;;;;;;;;;;;;;;;;;cCVa,QAAA;EAAA,iBAGkB,SAAA;EAAA,QAFrB,OAAA;cAEqB,SAAA,KAAa,CAAA,aAAc,CAAA;EAExD,IAAA,CAAA,GAAQ,CAAA;EAQR,IAAA,CAAA,GAAQ,CAAA;EAQR,KAAA,CAAA;AAAA"}

package/dist/factory/index.mjs

@@ -0,0 +1,138 @@
+import { faker } from "@faker-js/faker";
+//#region src/factory/factory.ts
+/**
+* Factory
+*
+* Abstract base class for creating test data.
+* Integrates with Faker.js for data generation.
+*
+* @example Define a factory
+* ```typescript
+* import { Factory } from '@stratal/framework/factory'
+* import type { User, UserCreateInput } from '@your-app/db'
+*
+* export class UserFactory extends Factory<User, UserCreateInput> {
+*   protected model = 'user'
+*
+*   protected definition(): UserCreateInput {
+*     return {
+*       email: this.faker.internet.email(),
+*       firstName: this.faker.person.firstName(),
+*       lastName: this.faker.person.lastName(),
+*       emailVerified: true,
+*     }
+*   }
+*
+*   admin() {
+*     return this.state(attrs => ({ ...attrs, role: 'admin' }))
+*   }
+* }
+* ```
+*
+* @example Usage
+* ```typescript
+* const user = await new UserFactory().create(ctx.db)
+* const admin = await new UserFactory().admin().create(ctx.db)
+* const users = await new UserFactory().count(10).createManyAndReturn(ctx.db)
+* ```
+*/
+var Factory = class {
+	faker = faker;
+	states = [];
+	_count = 1;
+	state(modifier) {
+		const clone = this.clone();
+		clone.states.push(modifier);
+		return clone;
+	}
+	count(n) {
+		const clone = this.clone();
+		clone._count = n;
+		return clone;
+	}
+	make() {
+		let attrs = this.definition();
+		for (const modifier of this.states) attrs = {
+			...attrs,
+			...modifier(attrs)
+		};
+		return attrs;
+	}
+	makeMany(count) {
+		const n = count ?? this._count;
+		return Array.from({ length: n }, () => this.make());
+	}
+	async create(db) {
+		const data = this.make();
+		return db[this.model].create({ data });
+	}
+	async createMany(db, count) {
+		const data = this.makeMany(count);
+		return db[this.model].createMany({ data });
+	}
+	async createManyAndReturn(db, count) {
+		const data = this.makeMany(count);
+		return db[this.model].createManyAndReturn({ data });
+	}
+	clone() {
+		const FactoryClass = this.constructor;
+		const clone = new FactoryClass();
+		clone.states = [...this.states];
+		clone._count = this._count;
+		return clone;
+	}
+};
+//#endregion
+//#region src/factory/sequence.ts
+/**
+* Sequence
+*
+* Auto-incrementing sequence generator for creating unique values.
+*
+* @example Basic usage
+* ```typescript
+* const emailSeq = new Sequence((n) => `user${n}@example.com`)
+*
+* emailSeq.next() // 'user1@example.com'
+* emailSeq.next() // 'user2@example.com'
+* emailSeq.reset()
+* emailSeq.next() // 'user1@example.com'
+* ```
+*
+* @example With factory
+* ```typescript
+* const orderSeq = new Sequence((n) => `ORD-${String(n).padStart(6, '0')}`)
+*
+* export class OrderFactory extends Factory<Order, OrderCreateInput> {
+*   protected definition() {
+*     return {
+*       orderNumber: orderSeq.next(),
+*       // ...
+*     }
+*   }
+* }
+* ```
+*/
+var Sequence = class {
+	current = 0;
+	constructor(generator) {
+		this.generator = generator;
+	}
+	next() {
+		this.current++;
+		if (this.generator) return this.generator(this.current);
+		return this.current;
+	}
+	peek() {
+		const value = this.current + 1;
+		if (this.generator) return this.generator(value);
+		return value;
+	}
+	reset() {
+		this.current = 0;
+	}
+};
+//#endregion
+export { Factory, Sequence };
+
+//# sourceMappingURL=index.mjs.map

package/dist/factory/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/factory/factory.ts","../../src/factory/sequence.ts"],"sourcesContent":["import { faker, type Faker } from '@faker-js/faker'\nimport type { DatabaseService } from '../database'\n\n/**\n * Factory\n *\n * Abstract base class for creating test data.\n * Integrates with Faker.js for data generation.\n *\n * @example Define a factory\n * ```typescript\n * import { Factory } from '@stratal/framework/factory'\n * import type { User, UserCreateInput } from '@your-app/db'\n *\n * export class UserFactory extends Factory<User, UserCreateInput> {\n *   protected model = 'user'\n *\n *   protected definition(): UserCreateInput {\n *     return {\n *       email: this.faker.internet.email(),\n *       firstName: this.faker.person.firstName(),\n *       lastName: this.faker.person.lastName(),\n *       emailVerified: true,\n *     }\n *   }\n *\n *   admin() {\n *     return this.state(attrs => ({ ...attrs, role: 'admin' }))\n *   }\n * }\n * ```\n *\n * @example Usage\n * ```typescript\n * const user = await new UserFactory().create(ctx.db)\n * const admin = await new UserFactory().admin().create(ctx.db)\n * const users = await new UserFactory().count(10).createManyAndReturn(ctx.db)\n * ```\n */\nexport abstract class Factory<TModel, TCreateInput> {\n  protected readonly faker: Faker = faker\n  protected abstract model: string\n  protected abstract definition(): TCreateInput\n\n  private states: ((attrs: TCreateInput) => Partial<TCreateInput>)[] = []\n  private _count = 1\n\n  state(modifier: (attrs: TCreateInput) => Partial<TCreateInput>): this {\n    const clone = this.clone()\n    clone.states.push(modifier)\n    return clone\n  }\n\n  count(n: number): this {\n    const clone = this.clone()\n    clone._count = n\n    return clone\n  }\n\n  make(): TCreateInput {\n    let attrs = this.definition()\n    for (const modifier of this.states) {\n      attrs = { ...attrs, ...modifier(attrs) }\n    }\n    return attrs\n  }\n\n  makeMany(count?: number): TCreateInput[] {\n    const n = count ?? this._count\n    return Array.from({ length: n }, () => this.make())\n  }\n\n  async create(db: DatabaseService): Promise<TModel> {\n    const data = this.make()\n    const model = (db as unknown as Record<string, { create: (args: { data: TCreateInput }) => Promise<TModel> }>)[this.model]\n    return model.create({ data })\n  }\n\n  async createMany(db: DatabaseService, count?: number): Promise<{ count: number }> {\n    const data = this.makeMany(count)\n    const model = (db as unknown as Record<string, { createMany: (args: { data: TCreateInput[] }) => Promise<{ count: number }> }>)[this.model]\n    return model.createMany({ data })\n  }\n\n  async createManyAndReturn(db: DatabaseService, count?: number): Promise<TModel[]> {\n    const data = this.makeMany(count)\n    const model = (db as unknown as Record<string, { createManyAndReturn: (args: { data: TCreateInput[] }) => Promise<TModel[]> }>)[this.model]\n    return model.createManyAndReturn({ data })\n  }\n\n  protected clone(): this {\n    const FactoryClass = this.constructor as new () => this\n    const clone = new FactoryClass()\n    clone.states = [...this.states]\n    clone._count = this._count\n    return clone\n  }\n}\n","/**\n * Sequence\n *\n * Auto-incrementing sequence generator for creating unique values.\n *\n * @example Basic usage\n * ```typescript\n * const emailSeq = new Sequence((n) => `user${n}@example.com`)\n *\n * emailSeq.next() // 'user1@example.com'\n * emailSeq.next() // 'user2@example.com'\n * emailSeq.reset()\n * emailSeq.next() // 'user1@example.com'\n * ```\n *\n * @example With factory\n * ```typescript\n * const orderSeq = new Sequence((n) => `ORD-${String(n).padStart(6, '0')}`)\n *\n * export class OrderFactory extends Factory<Order, OrderCreateInput> {\n *   protected definition() {\n *     return {\n *       orderNumber: orderSeq.next(),\n *       // ...\n *     }\n *   }\n * }\n * ```\n */\nexport class Sequence<T = number> {\n  private current = 0\n\n  constructor(private readonly generator?: (n: number) => T) {}\n\n  next(): T {\n    this.current++\n    if (this.generator) {\n      return this.generator(this.current)\n    }\n    return this.current as T\n  }\n\n  peek(): T {\n    const value = this.current + 1\n    if (this.generator) {\n      return this.generator(value)\n    }\n    return value as T\n  }\n\n  reset(): void {\n    this.current = 0\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,IAAsB,UAAtB,MAAoD;CAClD,QAAkC;CAIlC,SAAqE,EAAE;CACvE,SAAiB;CAEjB,MAAM,UAAgE;EACpE,MAAM,QAAQ,KAAK,OAAO;AAC1B,QAAM,OAAO,KAAK,SAAS;AAC3B,SAAO;;CAGT,MAAM,GAAiB;EACrB,MAAM,QAAQ,KAAK,OAAO;AAC1B,QAAM,SAAS;AACf,SAAO;;CAGT,OAAqB;EACnB,IAAI,QAAQ,KAAK,YAAY;AAC7B,OAAK,MAAM,YAAY,KAAK,OAC1B,SAAQ;GAAE,GAAG;GAAO,GAAG,SAAS,MAAM;GAAE;AAE1C,SAAO;;CAGT,SAAS,OAAgC;EACvC,MAAM,IAAI,SAAS,KAAK;AACxB,SAAO,MAAM,KAAK,EAAE,QAAQ,GAAG,QAAQ,KAAK,MAAM,CAAC;;CAGrD,MAAM,OAAO,IAAsC;EACjD,MAAM,OAAO,KAAK,MAAM;AAExB,SADe,GAAgG,KAAK,OACvG,OAAO,EAAE,MAAM,CAAC;;CAG/B,MAAM,WAAW,IAAqB,OAA4C;EAChF,MAAM,OAAO,KAAK,SAAS,MAAM;AAEjC,SADe,GAAiH,KAAK,OACxH,WAAW,EAAE,MAAM,CAAC;;CAGnC,MAAM,oBAAoB,IAAqB,OAAmC;EAChF,MAAM,OAAO,KAAK,SAAS,MAAM;AAEjC,SADe,GAAiH,KAAK,OACxH,oBAAoB,EAAE,MAAM,CAAC;;CAG5C,QAAwB;EACtB,MAAM,eAAe,KAAK;EAC1B,MAAM,QAAQ,IAAI,cAAc;AAChC,QAAM,SAAS,CAAC,GAAG,KAAK,OAAO;AAC/B,QAAM,SAAS,KAAK;AACpB,SAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AClEX,IAAa,WAAb,MAAkC;CAChC,UAAkB;CAElB,YAAY,WAA+C;AAA9B,OAAA,YAAA;;CAE7B,OAAU;AACR,OAAK;AACL,MAAI,KAAK,UACP,QAAO,KAAK,UAAU,KAAK,QAAQ;AAErC,SAAO,KAAK;;CAGd,OAAU;EACR,MAAM,QAAQ,KAAK,UAAU;AAC7B,MAAI,KAAK,UACP,QAAO,KAAK,UAAU,MAAM;AAE9B,SAAO;;CAGT,QAAc;AACZ,OAAK,UAAU"}

package/dist/guards/{auth.guard.d.ts → index.d.mts}

@@ -1,4 +1,6 @@
-import type { AuthGuardOptions, GuardClass } from 'stratal/guards';
+import { AuthGuardOptions, AuthGuardOptions as AuthGuardOptions$1, CanActivate, GUARD_METADATA_KEY, Guard, GuardClass, GuardClass as GuardClass$1, GuardExecutionService, GuardMetadata, UseGuards, getControllerGuards, getMethodGuards } from "stratal/guards";
+
+//#region src/guards/auth.guard.d.ts
 /**
  * AuthGuard Factory
  *
@@ -29,5 +31,7 @@ import type { AuthGuardOptions, GuardClass } from 'stratal/guards';
  * export class StudentsController { }
  * ```
  */
-export declare function AuthGuard(options?: AuthGuardOptions): GuardClass;
-//# sourceMappingURL=auth.guard.d.ts.map
+declare function AuthGuard(options?: AuthGuardOptions$1): GuardClass$1;
+//#endregion
+export { AuthGuard, type AuthGuardOptions, type CanActivate, GUARD_METADATA_KEY, type Guard, type GuardClass, GuardExecutionService, type GuardMetadata, UseGuards, getControllerGuards, getMethodGuards };
+//# sourceMappingURL=index.d.mts.map

package/dist/guards/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/guards/auth.guard.ts"],"mappings":";;;;;AAyCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,SAAA,CAAU,OAAA,GAAU,kBAAA,GAAmB,YAAA"}

package/dist/guards/index.mjs

@@ -0,0 +1,93 @@
+import { n as UserNotAuthenticatedError } from "../errors-C_KIIU1v.mjs";
+import { t as __decorate } from "../decorate-RSane8dy.mjs";
+import { t as __decorateMetadata } from "../decorateMetadata-CETItPez.mjs";
+import { t as __decorateParam } from "../decorateParam-CcTvpNsw.mjs";
+import { n as InsufficientPermissionsError, t as RBAC_TOKENS } from "../tokens-Di1ofovy.mjs";
+import { DI_TOKENS, Transient } from "stratal/di";
+import { inject } from "tsyringe";
+import { GUARD_METADATA_KEY, GuardExecutionService, UseGuards, getControllerGuards, getMethodGuards } from "stratal/guards";
+import { LOGGER_TOKENS } from "stratal/logger";
+//#region src/guards/auth.guard.ts
+/**
+* AuthGuard Factory
+*
+* Creates a guard class that enforces authentication and optional authorization.
+*
+* **Authentication (no scopes):**
+* - Checks if user is authenticated via AuthContext.isAuthenticated()
+* - Throws UserNotAuthenticatedError (401) if not authenticated
+*
+* **Authorization (with scopes):**
+* - First verifies authentication
+* - Then checks permissions via CasbinService
+* - Throws InsufficientPermissionsError (403) if unauthorized
+*
+* @param options - Configuration options
+* @param options.scopes - Required permissions for authorization
+* @returns Guard class for use with @UseGuards decorator
+*
+* @example Authentication only
+* ```typescript
+* @UseGuards(AuthGuard())
+* export class ProfileController { }
+* ```
+*
+* @example Authentication with permissions
+* ```typescript
+* @UseGuards(AuthGuard({ scopes: ['students:read'] }))
+* export class StudentsController { }
+* ```
+*/
+function AuthGuard(options) {
+	const scopes = options?.scopes;
+	let ConfiguredAuthGuard = class ConfiguredAuthGuard {
+		constructor(authContext, logger, casbinService) {
+			this.authContext = authContext;
+			this.logger = logger;
+			this.casbinService = casbinService;
+		}
+		async canActivate(context) {
+			if (!this.authContext.isAuthenticated()) {
+				this.logger.debug("Auth guard: User not authenticated");
+				throw new UserNotAuthenticatedError();
+			}
+			if (!scopes || scopes.length === 0) {
+				this.logger.debug("Auth guard: Authentication passed (no scopes required)");
+				return true;
+			}
+			const userId = this.authContext.getUserId();
+			if (!userId) {
+				this.logger.debug("Auth guard: No user ID in context");
+				throw new InsufficientPermissionsError(scopes, void 0);
+			}
+			const httpMethod = context.c.req.method.toLowerCase();
+			if (this.casbinService) {
+				const hasPermission = await this.casbinService.hasAnyPermission(userId, scopes, httpMethod);
+				this.logger.debug("Auth guard: Authorization check", {
+					userId,
+					scopes,
+					httpMethod,
+					hasPermission
+				});
+				if (!hasPermission) throw new InsufficientPermissionsError(scopes, userId);
+			}
+			return true;
+		}
+	};
+	ConfiguredAuthGuard = __decorate([
+		Transient(),
+		__decorateParam(0, inject(DI_TOKENS.AuthContext)),
+		__decorateParam(1, inject(LOGGER_TOKENS.LoggerService)),
+		__decorateParam(2, inject(RBAC_TOKENS.CasbinService, { isOptional: true })),
+		__decorateMetadata("design:paramtypes", [
+			Object,
+			Object,
+			Object
+		])
+	], ConfiguredAuthGuard);
+	return ConfiguredAuthGuard;
+}
+//#endregion
+export { AuthGuard, GUARD_METADATA_KEY, GuardExecutionService, UseGuards, getControllerGuards, getMethodGuards };
+
+//# sourceMappingURL=index.mjs.map

package/dist/guards/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/guards/auth.guard.ts"],"sourcesContent":["import { DI_TOKENS, Transient } from 'stratal/di'\nimport type { AuthGuardOptions, CanActivate, GuardClass } from 'stratal/guards'\nimport { LOGGER_TOKENS, type LoggerService } from 'stratal/logger'\nimport type { RouterContext } from 'stratal/router'\nimport { inject } from 'tsyringe'\nimport type { AuthContext } from '../context/auth-context'\nimport { UserNotAuthenticatedError } from '../context/errors'\nimport { InsufficientPermissionsError } from '../rbac/errors/insufficient-permissions.error'\nimport type { CasbinService } from '../rbac/services/casbin.service'\nimport { RBAC_TOKENS } from '../rbac/tokens'\n\n/**\n * AuthGuard Factory\n *\n * Creates a guard class that enforces authentication and optional authorization.\n *\n * **Authentication (no scopes):**\n * - Checks if user is authenticated via AuthContext.isAuthenticated()\n * - Throws UserNotAuthenticatedError (401) if not authenticated\n *\n * **Authorization (with scopes):**\n * - First verifies authentication\n * - Then checks permissions via CasbinService\n * - Throws InsufficientPermissionsError (403) if unauthorized\n *\n * @param options - Configuration options\n * @param options.scopes - Required permissions for authorization\n * @returns Guard class for use with @UseGuards decorator\n *\n * @example Authentication only\n * ```typescript\n * @UseGuards(AuthGuard())\n * export class ProfileController { }\n * ```\n *\n * @example Authentication with permissions\n * ```typescript\n * @UseGuards(AuthGuard({ scopes: ['students:read'] }))\n * export class StudentsController { }\n * ```\n */\nexport function AuthGuard(options?: AuthGuardOptions): GuardClass {\n  const scopes = options?.scopes\n\n  @Transient()\n  class ConfiguredAuthGuard implements CanActivate {\n    constructor(\n      @inject(DI_TOKENS.AuthContext) private readonly authContext: AuthContext,\n      @inject(LOGGER_TOKENS.LoggerService) private readonly logger: LoggerService,\n      @inject(RBAC_TOKENS.CasbinService, { isOptional: true }) private readonly casbinService?: CasbinService\n    ) { }\n\n    async canActivate(context: RouterContext): Promise<boolean> {\n      if (!this.authContext.isAuthenticated()) {\n        this.logger.debug('Auth guard: User not authenticated')\n        throw new UserNotAuthenticatedError()\n      }\n\n      if (!scopes || scopes.length === 0) {\n        this.logger.debug('Auth guard: Authentication passed (no scopes required)')\n        return true\n      }\n\n      const userId = this.authContext.getUserId()\n      if (!userId) {\n        this.logger.debug('Auth guard: No user ID in context')\n        throw new InsufficientPermissionsError(scopes, undefined)\n      }\n\n      const httpMethod = context.c.req.method.toLowerCase()\n\n      if (this.casbinService) {\n        const hasPermission = await this.casbinService.hasAnyPermission(\n          userId,\n          scopes,\n          httpMethod\n        )\n\n        this.logger.debug('Auth guard: Authorization check', {\n          userId,\n          scopes,\n          httpMethod,\n          hasPermission,\n        })\n\n        if (!hasPermission) {\n          throw new InsufficientPermissionsError(scopes, userId)\n        }\n      }\n\n      return true\n    }\n  }\n\n  return ConfiguredAuthGuard\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,SAAgB,UAAU,SAAwC;CAChE,MAAM,SAAS,SAAS;CAExB,IAAA,sBAAA,MACM,oBAA2C;EAC/C,YACE,aACA,QACA,eACA;AAHgD,QAAA,cAAA;AACM,QAAA,SAAA;AACoB,QAAA,gBAAA;;EAG5E,MAAM,YAAY,SAA0C;AAC1D,OAAI,CAAC,KAAK,YAAY,iBAAiB,EAAE;AACvC,SAAK,OAAO,MAAM,qCAAqC;AACvD,UAAM,IAAI,2BAA2B;;AAGvC,OAAI,CAAC,UAAU,OAAO,WAAW,GAAG;AAClC,SAAK,OAAO,MAAM,yDAAyD;AAC3E,WAAO;;GAGT,MAAM,SAAS,KAAK,YAAY,WAAW;AAC3C,OAAI,CAAC,QAAQ;AACX,SAAK,OAAO,MAAM,oCAAoC;AACtD,UAAM,IAAI,6BAA6B,QAAQ,KAAA,EAAU;;GAG3D,MAAM,aAAa,QAAQ,EAAE,IAAI,OAAO,aAAa;AAErD,OAAI,KAAK,eAAe;IACtB,MAAM,gBAAgB,MAAM,KAAK,cAAc,iBAC7C,QACA,QACA,WACD;AAED,SAAK,OAAO,MAAM,mCAAmC;KACnD;KACA;KACA;KACA;KACD,CAAC;AAEF,QAAI,CAAC,cACH,OAAM,IAAI,6BAA6B,QAAQ,OAAO;;AAI1D,UAAO;;;;EA9CV,WAAW;qBAGP,OAAO,UAAU,YAAY,CAAA;qBAC7B,OAAO,cAAc,cAAc,CAAA;qBACnC,OAAO,YAAY,eAAe,EAAE,YAAY,MAAM,CAAC,CAAA;;;;;;;AA6C5D,QAAO"}