@nmnmcc/ability 0.1.0 → 0.2.0

package/dist/Ability.d.ts

@@ -1,5 +1,5 @@
-import { AliasError as AliasError$1, AuthorizationError as AuthorizationError$1, ConditionError as ConditionError$1, PredicateEvaluationError as PredicateEvaluationError$1, QueryGenerationError as QueryGenerationError$1, RawRuleError as RawRuleError$1, RuleTypeId as RuleTypeId$1, SerializationError as SerializationError$1, SubjectDetectionError as SubjectDetectionError$1, SubjectTypeId as SubjectTypeId$1, TypeId as TypeId$1 } from "./internal/ability.js";
-import { MongoQuery } from "@ucast/mongo2js";
+import { AliasError as AliasError$1, AuthorizationError as AuthorizationError$1, ConditionError as ConditionError$1, QueryGenerationError as QueryGenerationError$1, RawRuleError as RawRuleError$1, RuleTypeId as RuleTypeId$1, SubjectDetectionError as SubjectDetectionError$1, SubjectTypeId as SubjectTypeId$1, TypeId as TypeId$1 } from "./internal/ability.js";
+import { MongoQuery } from "@casl/ability";
 import * as Effect from "effect/Effect";
 import * as Equal from "effect/Equal";
 import * as Inspectable from "effect/Inspectable";
@@ -7,7 +7,7 @@ import * as Pipeable from "effect/Pipeable";
 
 //#region src/Ability.d.ts
 declare namespace Ability_d_exports {
-  export { Ability, AbilityOptions, ActionAliases, ActionResolver, AliasError, AnyAction, AnyRule, AnySubject, AuthorizationError, Builder, CheckRequest, ConditionError, DetectSubjectType, ExpandedAction, FieldOf, FieldPath, FieldPattern, MongoCondition, PermittedFieldsOptions, Predicate, PredicateEvaluationError, QueryGenerationError, RawRule, RawRuleError, Rule, RuleKind, RuleOptions, RuleQueryRequest, RuleSubject, RuleTypeId, SerializationError, SingleOrReadonlyArray, SubjectDetectionError, SubjectMap, SubjectName, SubjectQueryRequest, SubjectTypeId, SubjectUnion, ToRawRulesOptions, TypeId, TypedSubject, actionsFor, check, createAliasResolver, define, detectSubjectType, fromRawRules, isAbility, isRule, isSubject, make, permittedFields, possibleRulesFor, relevantRuleFor, rulesFor, subject, toRawRules, unwrapSubject };
+  export { Ability, AbilityOptions, ActionAliases, ActionResolver, AliasError, AnyAction, AnyRule, AnySubject, AuthorizationError, Builder, CheckRequest, ConditionError, DetectSubjectType, ExpandedAction, FieldOf, FieldPath, FieldPattern, MongoCondition, PermittedFieldsOptions, QueryGenerationError, RawRule, RawRuleError, Rule, RuleKind, RuleOptions, RuleQueryRequest, RuleSubject, RuleTypeId, SingleOrReadonlyArray, SubjectDetectionError, SubjectMap, SubjectName, SubjectQueryRequest, SubjectTypeId, SubjectUnion, TypeId, TypedSubject, actionsFor, check, createAliasResolver, define, detectSubjectType, fromRawRules, isAbility, isRule, isSubject, make, permittedFields, possibleRulesFor, relevantRuleFor, rulesFor, subject, toRawRules, unwrapSubject, update };
 }
 /**
  * @since 0.1.0
@@ -107,11 +107,7 @@ type FieldPattern = `${string}*${string}`;
  * @category Models
  */
 type FieldOf<Subject> = string & (FieldPath<Subject> | FieldPattern);
-/**
- * @since 0.1.0
- * @category Models
- */
-type MongoCondition<Subject extends object> = MongoQuery<Subject> & Readonly<Record<string, unknown>>;
+type MongoCondition<Subject extends object> = MongoQuery<Subject>;
 /**
  * @since 0.1.0
  * @category Models
@@ -121,36 +117,29 @@ type RuleKind = "Allow" | "Deny";
  * @since 0.1.0
  * @category Models
  */
-type Predicate<Subject, E = never, R = never> = (subject: Subject) => boolean | Effect.Effect<boolean, E, R>;
-/**
- * @since 0.1.0
- * @category Models
- */
-interface RuleOptions<Subject extends object, Fields extends string, E = never, R = never> {
+interface RuleOptions<Subject extends object, Fields extends string> {
   readonly fields?: SingleOrReadonlyArray<Fields>;
   readonly conditions?: MongoCondition<Subject>;
-  readonly when?: Predicate<Subject, E, R>;
   readonly reason?: string;
 }
 /**
  * @since 0.1.0
  * @category Models
  */
-interface Rule<Kind extends RuleKind, Action extends string, Name extends string, Subject extends object, Fields extends string, E, R> extends Equal.Equal, Inspectable.Inspectable, Pipeable.Pipeable, Effect.Yieldable<Rule<Kind, Action, Name, Subject, Fields, E, R>, Rule<Kind, Action, Name, Subject, Fields, E, R>> {
+interface Rule<Kind extends RuleKind, Action extends string, Name extends string, Subject extends object, Fields extends string> extends Equal.Equal, Inspectable.Inspectable, Pipeable.Pipeable, Effect.Yieldable<Rule<Kind, Action, Name, Subject, Fields>, Rule<Kind, Action, Name, Subject, Fields>> {
   readonly [RuleTypeId]: RuleTypeId;
   readonly _tag: Kind;
   readonly action: SingleOrReadonlyArray<Action>;
   readonly subject: SingleOrReadonlyArray<Name>;
   readonly fields?: ReadonlyArray<Fields>;
   readonly conditions?: MongoCondition<Subject>;
-  readonly when?: Predicate<Subject, E, R>;
   readonly reason?: string;
 }
 /**
  * @since 0.1.0
  * @category Models
  */
-type AnyRule = Rule<RuleKind, string, string, any, string, any, any>;
+type AnyRule = Rule<RuleKind, string, string, any, string>;
 /**
  * @since 0.1.0
  * @category Models
@@ -202,8 +191,8 @@ type ExpandedAction<Action extends string, Aliases extends ActionAliases, Depth
  * @category Models
  */
 interface Builder<Subjects extends SubjectMap> {
-  readonly allow: <const Action extends SingleOrReadonlyArray<string>, const Name extends SingleOrReadonlyArray<RuleSubject<Subjects>>, const Fields extends FieldOf<SubjectFor<Subjects, ElementOf<Name>> & object> = FieldOf<SubjectFor<Subjects, ElementOf<Name>> & object>, E = never, R = never>(action: Action, subject: Name, options?: RuleOptions<SubjectFor<Subjects, ElementOf<Name>> & object, Fields, E, R>) => Rule<"Allow", ElementOf<Action> & string, ElementOf<Name> & string, SubjectFor<Subjects, ElementOf<Name>> & object, Fields, E, R>;
-  readonly deny: <const Action extends SingleOrReadonlyArray<string>, const Name extends SingleOrReadonlyArray<RuleSubject<Subjects>>, const Fields extends FieldOf<SubjectFor<Subjects, ElementOf<Name>> & object> = FieldOf<SubjectFor<Subjects, ElementOf<Name>> & object>, E = never, R = never>(action: Action, subject: Name, options?: RuleOptions<SubjectFor<Subjects, ElementOf<Name>> & object, Fields, E, R>) => Rule<"Deny", ElementOf<Action> & string, ElementOf<Name> & string, SubjectFor<Subjects, ElementOf<Name>> & object, Fields, E, R>;
+  readonly allow: <const Action extends SingleOrReadonlyArray<string>, const Name extends SingleOrReadonlyArray<RuleSubject<Subjects>>, const Fields extends FieldOf<SubjectFor<Subjects, ElementOf<Name>> & object> = FieldOf<SubjectFor<Subjects, ElementOf<Name>> & object>>(action: Action, subject: Name, options?: RuleOptions<SubjectFor<Subjects, ElementOf<Name>> & object, Fields>) => Rule<"Allow", ElementOf<Action> & string, ElementOf<Name> & string, SubjectFor<Subjects, ElementOf<Name>> & object, Fields>;
+  readonly deny: <const Action extends SingleOrReadonlyArray<string>, const Name extends SingleOrReadonlyArray<RuleSubject<Subjects>>, const Fields extends FieldOf<SubjectFor<Subjects, ElementOf<Name>> & object> = FieldOf<SubjectFor<Subjects, ElementOf<Name>> & object>>(action: Action, subject: Name, options?: RuleOptions<SubjectFor<Subjects, ElementOf<Name>> & object, Fields>) => Rule<"Deny", ElementOf<Action> & string, ElementOf<Name> & string, SubjectFor<Subjects, ElementOf<Name>> & object, Fields>;
 }
 /**
  * @since 0.1.0
@@ -217,35 +206,38 @@ interface RawRule<Action extends string = string, Name extends string = string,
   readonly inverted?: boolean;
   readonly reason?: string;
 }
-type RuleAction<Rules> = Rules extends Rule<infer _Kind, infer Action, infer _Name, infer _Subject, infer _Fields, infer _E, infer _R> ? Action : never;
-type RuleSubjectName<Rules> = Rules extends Rule<infer _Kind, infer _Action, infer Name, infer _Subject, infer _Fields, infer _E, infer _R> ? Name : never;
-type RuleFields<Rules> = Rules extends Rule<infer _Kind, infer _Action, infer _Name, infer _Subject, infer Fields, infer _E, infer _R> ? Fields : never;
-type RuleError<Rules> = Rules extends Rule<infer _Kind, infer _Action, infer _Name, infer _Subject, infer _Fields, infer E, infer _R> ? E : never;
-type RuleServices<Rules> = Rules extends Rule<infer _Kind, infer _Action, infer _Name, infer _Subject, infer _Fields, infer _E, infer R> ? R : never;
+type RuleAction<Rules> = Rules extends Rule<infer _Kind, infer Action, infer _Name, infer _Subject, infer _Fields> ? Action : never;
+type RuleSubjectName<Rules> = Rules extends Rule<infer _Kind, infer _Action, infer Name, infer _Subject, infer _Fields> ? Name : never;
+type RuleFields<Rules> = Rules extends Rule<infer _Kind, infer _Action, infer _Name, infer _Subject, infer Fields> ? Fields : never;
 type ActionMatches<Rule, Action extends string, Aliases extends ActionAliases> = Rule extends AnyRule ? Action extends ExpandedAction<RuleAction<Rule> & string, Aliases> ? Rule : AnyAction extends RuleAction<Rule> ? Rule : never : never;
 type SubjectMatches<Rule, Name extends string> = Rule extends AnyRule ? Name extends RuleSubjectName<Rule> ? Rule : AnySubject extends RuleSubjectName<Rule> ? Rule : never : never;
 type RulesMatching<Rules, Action extends string, Name extends string, Aliases extends ActionAliases> = SubjectMatches<ActionMatches<Rules, Action, Aliases>, Name>;
-type AllowedActions<Rules, Aliases extends ActionAliases> = AnyAction extends RuleAction<Rules> ? string : ExpandedAction<RuleAction<Rules> & string, Aliases>;
-type AllowedSubjects<Subjects extends SubjectMap, Rules> = AnySubject extends RuleSubjectName<Rules> ? SubjectName<Subjects> : Extract<RuleSubjectName<Rules>, SubjectName<Subjects>>;
-type FieldFor<Subjects extends SubjectMap, Rules, Aliases extends ActionAliases, Action extends string, Name extends SubjectName<Subjects>> = RuleFields<RulesMatching<Rules, Action, Name, Aliases>> extends infer Fields ? [Fields] extends [never] ? FieldOf<Subjects[Name]> : Extract<Fields, FieldPattern> extends never ? Fields & string : FieldOf<Subjects[Name]> : never;
-type ExplicitCheckRequest<Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases> = AllowedSubjects<Subjects, Rules> extends infer Name ? Name extends SubjectName<Subjects> ? AllowedActions<Rules, Aliases> extends infer Action ? Action extends string ? {
+type RuleAllowedActions<Rule, Aliases extends ActionAliases> = Rule extends AnyRule ? AnyAction extends RuleAction<Rule> ? string : ExpandedAction<RuleAction<Rule> & string, Aliases> : never;
+type RuleAllowedSubjects<Subjects extends SubjectMap, Rule> = AnySubject extends RuleSubjectName<Rule> ? SubjectName<Subjects> : Extract<RuleSubjectName<Rule>, SubjectName<Subjects>>;
+type AllowedActions<Rules, Aliases extends ActionAliases> = RuleAllowedActions<Rules, Aliases>;
+type AllowedSubjects<Subjects extends SubjectMap, Rules> = RuleAllowedSubjects<Subjects, Rules>;
+type FieldFor<Subjects extends SubjectMap, Rules, Aliases extends ActionAliases, Action extends string, Name extends SubjectName<Subjects>> = RuleFields<RulesMatching<Rules, Action, Name, Aliases>> extends infer Fields ? [Fields] extends [never] ? never : string extends Fields & string ? FieldOf<Subjects[Name]> : Extract<Fields, FieldPattern> extends never ? Extract<Fields & string, FieldOf<Subjects[Name]>> : FieldOf<Subjects[Name]> : never;
+type ExplicitRuleCheckRequest<Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases, Rule extends AnyRule> = RuleAllowedActions<Rule, Aliases> extends infer Action ? Action extends string ? RuleAllowedSubjects<Subjects, Rule> extends infer Name ? Name extends SubjectName<Subjects> ? {
   readonly action: Action;
   readonly subject: Name;
   readonly value?: Subjects[Name] | TypedSubject<Name, Subjects[Name]>;
   readonly field?: FieldFor<Subjects, Rules, Aliases, Action, Name>;
 } : never : never : never : never;
-type TypedSubjectCheckRequest<Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases> = AllowedSubjects<Subjects, Rules> extends infer Name ? Name extends SubjectName<Subjects> ? AllowedActions<Rules, Aliases> extends infer Action ? Action extends string ? {
+type ExplicitCheckRequest<Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases> = Rules extends AnyRule ? ExplicitRuleCheckRequest<Subjects, Rules, Aliases, Rules> : never;
+type TypedSubjectRuleCheckRequest<Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases, Rule extends AnyRule> = RuleAllowedActions<Rule, Aliases> extends infer Action ? Action extends string ? RuleAllowedSubjects<Subjects, Rule> extends infer Name ? Name extends SubjectName<Subjects> ? {
   readonly action: Action;
   readonly subject?: never;
   readonly value: TypedSubject<Name, Subjects[Name]>;
   readonly field?: FieldFor<Subjects, Rules, Aliases, Action, Name>;
 } : never : never : never : never;
-type DetectedSubjectCheckRequest<Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases> = {
-  readonly action: AllowedActions<Rules, Aliases>;
+type TypedSubjectCheckRequest<Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases> = Rules extends AnyRule ? TypedSubjectRuleCheckRequest<Subjects, Rules, Aliases, Rules> : never;
+type DetectedSubjectRuleCheckRequest<Subjects extends SubjectMap, Aliases extends ActionAliases, Rule extends AnyRule> = RuleAllowedActions<Rule, Aliases> extends infer Action ? Action extends string ? RuleAllowedSubjects<Subjects, Rule> extends infer Name ? Name extends SubjectName<Subjects> ? {
+  readonly action: Action;
   readonly subject?: never;
-  readonly value: SubjectUnion<Subjects>;
+  readonly value: Subjects[Name];
   readonly field?: string;
-};
+} : never : never : never : never;
+type DetectedSubjectCheckRequest<Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases> = Rules extends AnyRule ? DetectedSubjectRuleCheckRequest<Subjects, Aliases, Rules> : never;
 /**
  * @since 0.1.0
  * @category Models
@@ -281,13 +273,6 @@ type RequestSubject<Request> = Request extends {
   readonly value: TypedSubject<infer Name, object>;
 } ? Name & string : string;
 type MatchingRules<Rules, Request, Aliases extends ActionAliases> = RulesMatching<Rules, RequestAction<Request>, RequestSubject<Request>, Aliases>;
-/**
- * @since 0.1.0
- * @category Models
- */
-interface ToRawRulesOptions {
-  readonly strict?: boolean;
-}
 /**
  * @since 0.1.0
  * @category Models
@@ -315,26 +300,6 @@ declare const ConditionError: typeof ConditionError$1;
  * @category Errors
  */
 type ConditionError = ConditionError$1;
-/**
- * @since 0.1.0
- * @category Errors
- */
-declare const PredicateEvaluationError: typeof PredicateEvaluationError$1;
-/**
- * @since 0.1.0
- * @category Errors
- */
-type PredicateEvaluationError = PredicateEvaluationError$1;
-/**
- * @since 0.1.0
- * @category Errors
- */
-declare const SerializationError: typeof SerializationError$1;
-/**
- * @since 0.1.0
- * @category Errors
- */
-type SerializationError = SerializationError$1;
 /**
  * @since 0.1.0
  * @category Errors
@@ -402,7 +367,17 @@ declare const make: <Subjects extends SubjectMap, Rules extends AnyRule, const A
  * @since 0.1.0
  * @category Constructors
  */
-declare const fromRawRules: <Subjects extends SubjectMap, const Aliases extends ActionAliases = {}>(rules: Iterable<RawRule<string, RuleSubject<Subjects>, string, MongoCondition<SubjectUnion<Subjects>>>>, options?: AbilityOptions<Subjects, Aliases>) => Effect.Effect<Ability<Subjects, AnyRule, Aliases>, AliasError | RawRuleError>;
+declare const fromRawRules: <Subjects extends SubjectMap, const Aliases extends ActionAliases = {}>(rules: Iterable<RawRule<string, RuleSubject<Subjects>, string, MongoCondition<any>>>, options?: AbilityOptions<Subjects, Aliases>) => Effect.Effect<Ability<Subjects, AnyRule, Aliases>, AliasError | RawRuleError>;
+/**
+ * Returns a new Ability from raw rules using an existing Ability's options.
+ *
+ * @since 0.1.0
+ * @category Constructors
+ */
+declare const update: {
+  <Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases>(rules: Iterable<RawRule<string, RuleSubject<Subjects>, string, MongoCondition<any>>>): (self: Ability<Subjects, Rules, Aliases>) => Effect.Effect<Ability<Subjects, AnyRule, Aliases>, AliasError | RawRuleError>;
+  <Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases>(self: Ability<Subjects, Rules, Aliases>, rules: Iterable<RawRule<string, RuleSubject<Subjects>, string, MongoCondition<any>>>): Effect.Effect<Ability<Subjects, AnyRule, Aliases>, AliasError | RawRuleError>;
+};
 /**
  * Creates a pure typed subject wrapper without mutating the wrapped value.
  *
@@ -451,9 +426,9 @@ declare const detectSubjectType: <Subjects extends SubjectMap, Rules extends Any
  * @since 0.1.0
  * @category Conversions
  */
-declare const toRawRules: <Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases>(self: Ability<Subjects, Rules, Aliases>, options?: ToRawRulesOptions) => Effect.Effect<ReadonlyArray<RawRule>, SerializationError>;
+declare const toRawRules: <Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases>(self: Ability<Subjects, Rules, Aliases>) => Effect.Effect<ReadonlyArray<RawRule>>;
 /**
- * Returns rules that may apply for a request before field, condition and predicate checks.
+ * Returns rules that may apply for a request before field and condition checks.
  *
  * @since 0.1.0
  * @category Accessors
@@ -479,8 +454,8 @@ declare const rulesFor: {
  * @category Accessors
  */
 declare const relevantRuleFor: {
-  <Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases, const Request extends RuleQueryRequest<Subjects, Rules, Aliases>>(request: Request): (self: Ability<Subjects, Rules, Aliases>) => Effect.Effect<MatchingRules<Rules, Request, Aliases> | undefined, ConditionError | PredicateEvaluationError | SubjectDetectionError | RuleError<MatchingRules<Rules, Request, Aliases>>, RuleServices<MatchingRules<Rules, Request, Aliases>>>;
-  <Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases, const Request extends RuleQueryRequest<Subjects, Rules, Aliases>>(self: Ability<Subjects, Rules, Aliases>, request: Request): Effect.Effect<MatchingRules<Rules, Request, Aliases> | undefined, ConditionError | PredicateEvaluationError | SubjectDetectionError | RuleError<MatchingRules<Rules, Request, Aliases>>, RuleServices<MatchingRules<Rules, Request, Aliases>>>;
+  <Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases, const Request extends RuleQueryRequest<Subjects, Rules, Aliases>>(request: Request): (self: Ability<Subjects, Rules, Aliases>) => Effect.Effect<MatchingRules<Rules, Request, Aliases> | undefined, ConditionError | SubjectDetectionError>;
+  <Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases, const Request extends RuleQueryRequest<Subjects, Rules, Aliases>>(self: Ability<Subjects, Rules, Aliases>, request: Request): Effect.Effect<MatchingRules<Rules, Request, Aliases> | undefined, ConditionError | SubjectDetectionError>;
 };
 /**
  * Returns actions that have rules for a subject.
@@ -499,8 +474,8 @@ declare const actionsFor: {
  * @category Combinators
  */
 declare const check: {
-  <Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases, const Request extends CheckRequest<Subjects, Rules, Aliases>>(request: Request): (self: Ability<Subjects, Rules, Aliases>) => Effect.Effect<void, AuthorizationError | ConditionError | PredicateEvaluationError | SubjectDetectionError | RuleError<MatchingRules<Rules, Request, Aliases>>, RuleServices<MatchingRules<Rules, Request, Aliases>>>;
-  <Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases, const Request extends CheckRequest<Subjects, Rules, Aliases>>(self: Ability<Subjects, Rules, Aliases>, request: Request): Effect.Effect<void, AuthorizationError | ConditionError | PredicateEvaluationError | SubjectDetectionError | RuleError<MatchingRules<Rules, Request, Aliases>>, RuleServices<MatchingRules<Rules, Request, Aliases>>>;
+  <Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases, const Request extends CheckRequest<Subjects, Rules, Aliases>>(request: Request): (self: Ability<Subjects, Rules, Aliases>) => Effect.Effect<void, AuthorizationError | ConditionError | SubjectDetectionError>;
+  <Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases, const Request extends CheckRequest<Subjects, Rules, Aliases>>(self: Ability<Subjects, Rules, Aliases>, request: Request): Effect.Effect<void, AuthorizationError | ConditionError | SubjectDetectionError>;
 };
 /**
  * Computes fields permitted for a request.
@@ -509,8 +484,8 @@ declare const check: {
  * @category Combinators
  */
 declare const permittedFields: {
-  <Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases, const Request extends CheckRequest<Subjects, Rules, Aliases>>(request: Request, options: PermittedFieldsOptions<Rules>): (self: Ability<Subjects, Rules, Aliases>) => Effect.Effect<ReadonlyArray<string>, ConditionError | PredicateEvaluationError | SubjectDetectionError | RuleError<MatchingRules<Rules, Request, Aliases>>, RuleServices<MatchingRules<Rules, Request, Aliases>>>;
-  <Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases, const Request extends CheckRequest<Subjects, Rules, Aliases>>(self: Ability<Subjects, Rules, Aliases>, request: Request, options: PermittedFieldsOptions<Rules>): Effect.Effect<ReadonlyArray<string>, ConditionError | PredicateEvaluationError | SubjectDetectionError | RuleError<MatchingRules<Rules, Request, Aliases>>, RuleServices<MatchingRules<Rules, Request, Aliases>>>;
+  <Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases, const Request extends CheckRequest<Subjects, Rules, Aliases>>(request: Request, options: PermittedFieldsOptions<Rules>): (self: Ability<Subjects, Rules, Aliases>) => Effect.Effect<ReadonlyArray<string>, ConditionError | SubjectDetectionError>;
+  <Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases, const Request extends CheckRequest<Subjects, Rules, Aliases>>(self: Ability<Subjects, Rules, Aliases>, request: Request, options: PermittedFieldsOptions<Rules>): Effect.Effect<ReadonlyArray<string>, ConditionError | SubjectDetectionError>;
 };
 //#endregion
-export { Ability, AbilityOptions, Ability_d_exports, ActionAliases, ActionResolver, AliasError, AnyAction, AnyRule, AnySubject, AuthorizationError, Builder, CheckRequest, ConditionError, DetectSubjectType, ExpandedAction, FieldOf, FieldPath, FieldPattern, MongoCondition, PermittedFieldsOptions, Predicate, PredicateEvaluationError, QueryGenerationError, RawRule, RawRuleError, Rule, RuleKind, RuleOptions, RuleQueryRequest, RuleSubject, RuleTypeId, SerializationError, SingleOrReadonlyArray, SubjectDetectionError, SubjectMap, SubjectName, SubjectQueryRequest, SubjectTypeId, SubjectUnion, ToRawRulesOptions, TypeId, TypedSubject, actionsFor, check, createAliasResolver, define, detectSubjectType, fromRawRules, isAbility, isRule, isSubject, make, permittedFields, possibleRulesFor, relevantRuleFor, rulesFor, subject, toRawRules, unwrapSubject };
+export { Ability, AbilityOptions, Ability_d_exports, ActionAliases, ActionResolver, AliasError, AnyAction, AnyRule, AnySubject, AuthorizationError, Builder, CheckRequest, ConditionError, DetectSubjectType, ExpandedAction, FieldOf, FieldPath, FieldPattern, MongoCondition, PermittedFieldsOptions, QueryGenerationError, RawRule, RawRuleError, Rule, RuleKind, RuleOptions, RuleQueryRequest, RuleSubject, RuleTypeId, SingleOrReadonlyArray, SubjectDetectionError, SubjectMap, SubjectName, SubjectQueryRequest, SubjectTypeId, SubjectUnion, TypeId, TypedSubject, actionsFor, check, createAliasResolver, define, detectSubjectType, fromRawRules, isAbility, isRule, isSubject, make, permittedFields, possibleRulesFor, relevantRuleFor, rulesFor, subject, toRawRules, unwrapSubject, update };

package/dist/Ability.js

@@ -1,15 +1,13 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
-import { AliasError as AliasError$1, AuthorizationError as AuthorizationError$1, ConditionError as ConditionError$1, PredicateEvaluationError as PredicateEvaluationError$1, QueryGenerationError as QueryGenerationError$1, RawRuleError as RawRuleError$1, RuleTypeId as RuleTypeId$1, SerializationError as SerializationError$1, SubjectDetectionError as SubjectDetectionError$1, SubjectTypeId as SubjectTypeId$1, TypeId as TypeId$1, actionsFor as actionsFor$1, check as check$1, createAliasResolver as createAliasResolver$1, define as define$1, detectSubjectType as detectSubjectType$1, fromRawRules as fromRawRules$1, isAbility as isAbility$1, isRule as isRule$1, isSubject as isSubject$1, make as make$1, permittedFields as permittedFields$1, possibleRulesFor as possibleRulesFor$1, relevantRuleFor as relevantRuleFor$1, rulesFor as rulesFor$1, subject as subject$1, toRawRules as toRawRules$1, unwrapSubject as unwrapSubject$1 } from "./internal/ability.js";
+import { AliasError as AliasError$1, AuthorizationError as AuthorizationError$1, ConditionError as ConditionError$1, QueryGenerationError as QueryGenerationError$1, RawRuleError as RawRuleError$1, RuleTypeId as RuleTypeId$1, SubjectDetectionError as SubjectDetectionError$1, SubjectTypeId as SubjectTypeId$1, TypeId as TypeId$1, actionsFor as actionsFor$1, check as check$1, createAliasResolver as createAliasResolver$1, define as define$1, detectSubjectType as detectSubjectType$1, fromRawRules as fromRawRules$1, isAbility as isAbility$1, isRule as isRule$1, isSubject as isSubject$1, make as make$1, permittedFields as permittedFields$1, possibleRulesFor as possibleRulesFor$1, relevantRuleFor as relevantRuleFor$1, rulesFor as rulesFor$1, subject as subject$1, toRawRules as toRawRules$1, unwrapSubject as unwrapSubject$1, update as update$1 } from "./internal/ability.js";
 //#region src/Ability.ts
 var Ability_exports = /* @__PURE__ */ __exportAll({
 	AliasError: () => AliasError,
 	AuthorizationError: () => AuthorizationError,
 	ConditionError: () => ConditionError,
-	PredicateEvaluationError: () => PredicateEvaluationError,
 	QueryGenerationError: () => QueryGenerationError,
 	RawRuleError: () => RawRuleError,
 	RuleTypeId: () => RuleTypeId,
-	SerializationError: () => SerializationError,
 	SubjectDetectionError: () => SubjectDetectionError,
 	SubjectTypeId: () => SubjectTypeId,
 	TypeId: () => TypeId,
@@ -29,7 +27,8 @@ var Ability_exports = /* @__PURE__ */ __exportAll({
 	rulesFor: () => rulesFor,
 	subject: () => subject,
 	toRawRules: () => toRawRules,
-	unwrapSubject: () => unwrapSubject
+	unwrapSubject: () => unwrapSubject,
+	update: () => update
 });
 /**
 * @since 0.1.0
@@ -62,16 +61,6 @@ const ConditionError = ConditionError$1;
 * @since 0.1.0
 * @category Errors
 */
-const PredicateEvaluationError = PredicateEvaluationError$1;
-/**
-* @since 0.1.0
-* @category Errors
-*/
-const SerializationError = SerializationError$1;
-/**
-* @since 0.1.0
-* @category Errors
-*/
 const RawRuleError = RawRuleError$1;
 /**
 * @since 0.1.0
@@ -117,6 +106,13 @@ const make = make$1;
 */
 const fromRawRules = fromRawRules$1;
 /**
+* Returns a new Ability from raw rules using an existing Ability's options.
+*
+* @since 0.1.0
+* @category Constructors
+*/
+const update = update$1;
+/**
 * Creates a pure typed subject wrapper without mutating the wrapped value.
 *
 * @since 0.1.0
@@ -166,7 +162,7 @@ const detectSubjectType = detectSubjectType$1;
 */
 const toRawRules = toRawRules$1;
 /**
-* Returns rules that may apply for a request before field, condition and predicate checks.
+* Returns rules that may apply for a request before field and condition checks.
 *
 * @since 0.1.0
 * @category Accessors
@@ -208,4 +204,4 @@ const check = check$1;
 */
 const permittedFields = permittedFields$1;
 //#endregion
-export { Ability_exports, AliasError, AuthorizationError, ConditionError, PredicateEvaluationError, QueryGenerationError, RawRuleError, RuleTypeId, SerializationError, SubjectDetectionError, SubjectTypeId, TypeId, actionsFor, check, createAliasResolver, define, detectSubjectType, fromRawRules, isAbility, isRule, isSubject, make, permittedFields, possibleRulesFor, relevantRuleFor, rulesFor, subject, toRawRules, unwrapSubject };
+export { Ability_exports, AliasError, AuthorizationError, ConditionError, QueryGenerationError, RawRuleError, RuleTypeId, SubjectDetectionError, SubjectTypeId, TypeId, actionsFor, check, createAliasResolver, define, detectSubjectType, fromRawRules, isAbility, isRule, isSubject, make, permittedFields, possibleRulesFor, relevantRuleFor, rulesFor, subject, toRawRules, unwrapSubject, update };

package/dist/AbilityExtra.d.ts

@@ -52,7 +52,7 @@ declare const unpackRules: <Rule extends RawRule = RawRule>(rules: Iterable<Pack
  * @category Conversions
  */
 declare const rulesToFields: {
-  <Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases, const Request extends RuleQueryRequest<Subjects, Rules, Aliases>>(request: Request): (self: Ability<Subjects, Rules, Aliases>) => Effect.Effect<Readonly<Record<string, unknown>>, QueryGenerationError | SubjectDetectionError>;
+  <const Request>(request: Request): <Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases>(self: Ability<Subjects, Rules, Aliases> & (Request extends RuleQueryRequest<Subjects, Rules, Aliases> ? unknown : never)) => Effect.Effect<Readonly<Record<string, unknown>>, QueryGenerationError | SubjectDetectionError>;
   <Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases, const Request extends RuleQueryRequest<Subjects, Rules, Aliases>>(self: Ability<Subjects, Rules, Aliases>, request: Request): Effect.Effect<Readonly<Record<string, unknown>>, QueryGenerationError | SubjectDetectionError>;
 };
 /**
@@ -62,7 +62,7 @@ declare const rulesToFields: {
  * @category Conversions
  */
 declare const rulesToCondition: {
-  <Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases, const Request extends RuleQueryRequest<Subjects, Rules, Aliases>, Query, E = never, R = never>(request: Request, convert: (rule: Rules) => Query | Effect.Effect<Query, E, R>, hooks: RulesToConditionHooks<Query>): (self: Ability<Subjects, Rules, Aliases>) => Effect.Effect<Query | null, QueryGenerationError | SubjectDetectionError | E, R>;
+  <const Request, Query, E = never, R = never>(request: Request, convert: (rule: AnyRule) => Query | Effect.Effect<Query, E, R>, hooks: RulesToConditionHooks<Query>): <Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases>(self: Ability<Subjects, Rules, Aliases> & (Request extends RuleQueryRequest<Subjects, Rules, Aliases> ? unknown : never)) => Effect.Effect<Query | null, QueryGenerationError | SubjectDetectionError | E, R>;
   <Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases, const Request extends RuleQueryRequest<Subjects, Rules, Aliases>, Query, E = never, R = never>(self: Ability<Subjects, Rules, Aliases>, request: Request, convert: (rule: Rules) => Query | Effect.Effect<Query, E, R>, hooks: RulesToConditionHooks<Query>): Effect.Effect<Query | null, QueryGenerationError | SubjectDetectionError | E, R>;
 };
 /**
@@ -72,7 +72,7 @@ declare const rulesToCondition: {
  * @category Conversions
  */
 declare const rulesToQuery: {
-  <Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases, const Request extends RuleQueryRequest<Subjects, Rules, Aliases>, Query, E = never, R = never>(request: Request, convert: (rule: Rules) => Query | Effect.Effect<Query, E, R>): (self: Ability<Subjects, Rules, Aliases>) => Effect.Effect<LogicalQuery<Query> | null, QueryGenerationError | SubjectDetectionError | E, R>;
+  <const Request, Query, E = never, R = never>(request: Request, convert: (rule: AnyRule) => Query | Effect.Effect<Query, E, R>): <Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases>(self: Ability<Subjects, Rules, Aliases> & (Request extends RuleQueryRequest<Subjects, Rules, Aliases> ? unknown : never)) => Effect.Effect<LogicalQuery<Query> | null, QueryGenerationError | SubjectDetectionError | E, R>;
   <Subjects extends SubjectMap, Rules extends AnyRule, Aliases extends ActionAliases, const Request extends RuleQueryRequest<Subjects, Rules, Aliases>, Query, E = never, R = never>(self: Ability<Subjects, Rules, Aliases>, request: Request, convert: (rule: Rules) => Query | Effect.Effect<Query, E, R>): Effect.Effect<LogicalQuery<Query> | null, QueryGenerationError | SubjectDetectionError | E, R>;
 };
 //#endregion

package/dist/AbilityExtra.js

@@ -19,8 +19,6 @@ import { dual } from "effect/Function";
 *   or {@link rulesToQuery}.
 *
 * Gotchas:
-* - Query generation rejects function predicates because they cannot be
-*   represented as static conditions.
 * - Conversion callbacks may be synchronous or Effectful; synchronous throws are
 *   converted to `QueryGenerationError`.
 *
@@ -101,10 +99,6 @@ const queryGenerationError = (reason, ruleIndex, cause) => {
 	if (cause !== void 0) error.cause = cause;
 	return new QueryGenerationError(error);
 };
-const assertSerializableRule = (rule, ruleIndex) => {
-	if (rule.when !== void 0) return Effect.fail(queryGenerationError("Cannot transform rules with function predicates", ruleIndex));
-	return Effect.void;
-};
 /**
 * Extracts scalar condition values as default fields.
 *
@@ -116,7 +110,6 @@ const rulesToFields = dual(2, Effect.fnUntraced(function* (self, request) {
 	const fields = {};
 	let index = 0;
 	for (const rule of rules) {
-		yield* assertSerializableRule(rule, index);
 		if (rule._tag === "Allow" && rule.conditions !== void 0) for (const key of Object.keys(rule.conditions)) {
 			const value = rule.conditions[key];
 			if (!isPlainObject(value)) setByPath(fields, key, value);
@@ -143,7 +136,6 @@ const rulesToConditionEffect = Effect.fnUntraced(function* (self, request, conve
 	let index = 0;
 	while (index < rules.length) {
 		const rule = rules[index];
-		yield* assertSerializableRule(rule, index);
 		if (rule._tag === "Deny") {
 			if (rule.conditions === void 0) break;
 			const condition = yield* convertRule(rule, convert, index);

package/dist/index.d.ts

@@ -1,4 +1,3 @@
 import { Ability_d_exports } from "./Ability.js";
 import { AbilityExtra_d_exports } from "./AbilityExtra.js";
-import { AbilityRef_d_exports } from "./AbilityRef.js";
-export { Ability_d_exports as Ability, AbilityExtra_d_exports as AbilityExtra, AbilityRef_d_exports as AbilityRef };
+export { Ability_d_exports as Ability, AbilityExtra_d_exports as AbilityExtra };

package/dist/index.js

@@ -1,4 +1,3 @@
 import { Ability_exports } from "./Ability.js";
 import { AbilityExtra_exports } from "./AbilityExtra.js";
-import { AbilityRef_exports } from "./AbilityRef.js";
-export { Ability_exports as Ability, AbilityExtra_exports as AbilityExtra, AbilityRef_exports as AbilityRef };
+export { Ability_exports as Ability, AbilityExtra_exports as AbilityExtra };

package/dist/internal/ability.d.ts

@@ -40,30 +40,6 @@ declare class ConditionError extends ConditionError_base<{
   readonly field?: string;
   readonly cause: unknown;
 }> {}
-declare const PredicateEvaluationError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
-  readonly _tag: "PredicateEvaluationError";
-} & Readonly<A>;
-/**
- * @since 0.1.0
- * @category Errors
- */
-declare class PredicateEvaluationError extends PredicateEvaluationError_base<{
-  readonly action: string;
-  readonly subject: string;
-  readonly field?: string;
-  readonly cause: unknown;
-}> {}
-declare const SerializationError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
-  readonly _tag: "SerializationError";
-} & Readonly<A>;
-/**
- * @since 0.1.0
- * @category Errors
- */
-declare class SerializationError extends SerializationError_base<{
-  readonly reason: string;
-  readonly ruleIndex?: number;
-}> {}
 declare const RawRuleError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
   readonly _tag: "RawRuleError";
 } & Readonly<A>;
@@ -111,4 +87,4 @@ declare class QueryGenerationError extends QueryGenerationError_base<{
   readonly cause?: unknown;
 }> {}
 //#endregion
-export { AliasError, AuthorizationError, ConditionError, PredicateEvaluationError, QueryGenerationError, RawRuleError, RuleTypeId, SerializationError, SubjectDetectionError, SubjectTypeId, TypeId };
+export { AliasError, AuthorizationError, ConditionError, QueryGenerationError, RawRuleError, RuleTypeId, SubjectDetectionError, SubjectTypeId, TypeId };