@nmnmcc/ability 0.1.0 → 0.3.0

package/dist/Condition.d.ts

@@ -0,0 +1,536 @@
+import { PathSegment } from "./Resource.js";
+import { Untranslatable as Untranslatable$1 } from "./internal/condition.js";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+declare namespace Condition_d_exports {
+  export { And, Any, Ast, Builder, Compare, CompareOperator, Condition, Encoded, EncodedAnd, EncodedNot, EncodedOr, Error, Exists, False, FieldPath, In, Input, Interpreter, Literal, Not, Opaque, OpaqueOf, Operand, OperandOf, Or, PathValue, Predicate, PrincipalRef, Ref, Scalar, Services, True, Under, Untranslatable, Variance, always, and, builder, evaluate, evaluateSync, fields, fold, never, not, or, partial, schema, simplify };
+}
+/**
+ * A value that a condition can compare.
+ *
+ * @stability stable
+ * @category models
+ * @since 0.3.0
+ */
+export type Scalar = string | number | boolean | null;
+/**
+ * A fixed value in a condition.
+ *
+ * @stability stable
+ * @category models
+ * @since 0.3.0
+ */
+export interface Literal {
+  readonly _tag: "Literal";
+  readonly value: Scalar;
+}
+/**
+ * A field of the principal. {@link partial} puts the value of the field in its
+ * place.
+ *
+ * A principal field that is `null` or missing has no value. A `Compare`, `In`
+ * or `Under` test with it is always false, also with `ne`. So a principal with
+ * no id never matches a resource with no owner. `not` still turns false into
+ * true.
+ *
+ * @stability stable
+ * @category models
+ * @since 0.3.0
+ */
+export interface PrincipalRef {
+  readonly _tag: "Principal";
+  readonly path: string;
+}
+/**
+ * A field of the principal with a known value type.
+ *
+ * @stability stable
+ * @category models
+ * @since 0.3.0
+ */
+export type Ref<A> = PrincipalRef & {
+  readonly "~Ref"?: () => A;
+};
+/**
+ * @stability stable
+ * @category models
+ * @since 0.3.0
+ */
+export type Operand = Literal | PrincipalRef;
+/**
+ * @stability stable
+ * @category models
+ * @since 0.3.0
+ */
+export type CompareOperator = "eq" | "ne" | "lt" | "lte" | "gt" | "gte";
+/**
+ * Always true.
+ *
+ * @stability stable
+ * @category models
+ * @since 0.3.0
+ */
+export interface True {
+  readonly _tag: "True";
+}
+/**
+ * Always false.
+ *
+ * @stability stable
+ * @category models
+ * @since 0.3.0
+ */
+export interface False {
+  readonly _tag: "False";
+}
+/**
+ * Compares a field with a value. A missing field has the value `null`. `lt`,
+ * `lte`, `gt` and `gte` are false when the two sides are not both numbers or
+ * both strings.
+ *
+ * @stability stable
+ * @category models
+ * @since 0.3.0
+ */
+export interface Compare {
+  readonly _tag: "Compare";
+  readonly op: CompareOperator;
+  readonly field: string;
+  readonly value: Operand;
+}
+/**
+ * True when a field is equal to one of the values.
+ *
+ * @stability stable
+ * @category models
+ * @since 0.3.0
+ */
+export interface In {
+  readonly _tag: "In";
+  readonly field: string;
+  readonly values: ReadonlyArray<Operand>;
+}
+/**
+ * True when a field is not `null` and not missing.
+ *
+ * @stability stable
+ * @category models
+ * @since 0.3.0
+ */
+export interface Exists {
+  readonly _tag: "Exists";
+  readonly field: string;
+}
+/**
+ * True when the path of the resource starts with the prefix. A resource with
+ * no path is never under a prefix.
+ *
+ * @stability stable
+ * @category models
+ * @since 0.3.0
+ */
+export interface Under {
+  readonly _tag: "Under";
+  readonly prefix: ReadonlyArray<Operand>;
+}
+/**
+ * @stability stable
+ * @category models
+ * @since 0.3.0
+ */
+export interface And {
+  readonly _tag: "And";
+  readonly conditions: ReadonlyArray<Ast>;
+}
+/**
+ * @stability stable
+ * @category models
+ * @since 0.3.0
+ */
+export interface Or {
+  readonly _tag: "Or";
+  readonly conditions: ReadonlyArray<Ast>;
+}
+/**
+ * @stability stable
+ * @category models
+ * @since 0.3.0
+ */
+export interface Not {
+  readonly _tag: "Not";
+  readonly condition: Ast;
+}
+/**
+ * A test that runs an `Effect`. It can not become JSON or a query.
+ *
+ * @stability stable
+ * @category models
+ * @since 0.3.0
+ */
+export interface Predicate {
+  readonly _tag: "Predicate";
+  readonly name: string;
+  readonly run: (value: any, principal: any) => Effect.Effect<boolean, unknown, unknown>;
+}
+/**
+ * The nodes of a condition, without types.
+ *
+ * @stability stable
+ * @category models
+ * @since 0.3.0
+ */
+export type Ast = True | False | Compare | In | Exists | Under | And | Or | Not | Predicate;
+/**
+ * The type marker for a condition with a {@link Predicate}.
+ *
+ * @stability stable
+ * @category models
+ * @since 0.3.0
+ */
+export type Opaque = "Opaque";
+/**
+ * @stability stable
+ * @category models
+ * @since 0.3.0
+ */
+export interface Variance<E, R, O> {
+  readonly E: () => E;
+  readonly R: () => R;
+  readonly O: () => O;
+}
+/**
+ * A condition. `E` and `R` are the error type and the service type of its
+ * predicates. `O` is {@link Opaque} when the condition has a predicate, and
+ * `never` when it is plain data.
+ *
+ * @stability stable
+ * @category models
+ * @since 0.3.0
+ */
+export type Condition<E = never, R = never, O = never> = Ast & {
+  readonly "~Condition"?: Variance<E, R, O>;
+};
+/**
+ * Any condition.
+ *
+ * @stability stable
+ * @category models
+ * @since 0.3.0
+ */
+export type Any = Condition<any, any, any>;
+/**
+ * The error type of a condition.
+ *
+ * @stability stable
+ * @category utility types
+ * @since 0.3.0
+ */
+export type Error<C> = C extends {
+  readonly "~Condition"?: Variance<infer E, infer _R, infer _O>;
+} ? E : never;
+/**
+ * The service type of a condition.
+ *
+ * @stability stable
+ * @category utility types
+ * @since 0.3.0
+ */
+export type Services<C> = C extends {
+  readonly "~Condition"?: Variance<infer _E, infer R, infer _O>;
+} ? R : never;
+/**
+ * {@link Opaque} when a condition has a predicate.
+ *
+ * @stability stable
+ * @category utility types
+ * @since 0.3.0
+ */
+export type OpaqueOf<C> = C extends {
+  readonly "~Condition"?: Variance<infer _E, infer _R, infer O>;
+} ? O : never;
+type Leaf = string | number | boolean | bigint | symbol | null | undefined;
+type PreviousDepth = [never, 0, 1, 2, 3];
+type FieldPathInternal<T, Depth extends number> = [Depth] extends [never] ? never : { [K in keyof T & string]-?: NonNullable<T[K]> extends Leaf ? K : NonNullable<T[K]> extends ReadonlyArray<unknown> | Function ? never : NonNullable<T[K]> extends object ? `${K}.${FieldPathInternal<NonNullable<T[K]>, PreviousDepth[Depth]>}` : never; }[keyof T & string];
+/**
+ * The paths of the fields of `T` that hold one value, with dots for nested
+ * fields. Arrays are left out. The type goes down four levels, so type
+ * checking stays fast. For a union of types, only the common fields are
+ * paths.
+ *
+ * @stability stable
+ * @category utility types
+ * @since 0.3.0
+ */
+export type FieldPath<T> = [T] extends [object] ? FieldPathInternal<T, 4> : never;
+type Normalize<A> = Exclude<A, undefined> | (undefined extends A ? null : never);
+/**
+ * The type of the field of `T` at `Path`. A field that may be missing may also
+ * be `null`.
+ *
+ * @stability stable
+ * @category utility types
+ * @since 0.3.0
+ */
+export type PathValue<T, Path extends string> = Path extends `${infer Head}.${infer Rest}` ? Head extends keyof T ? undefined extends T[Head] ? PathValue<NonNullable<T[Head]>, Rest> | null : null extends T[Head] ? PathValue<NonNullable<T[Head]>, Rest> | null : PathValue<T[Head], Rest> : never : Path extends keyof T ? Normalize<T[Path]> : never;
+/**
+ * A value for a field of type `A`: a fixed value, or a field of the principal
+ * with the same type.
+ *
+ * @stability stable
+ * @category models
+ * @since 0.3.0
+ */
+export type OperandOf<A> = Extract<A, Scalar> | Ref<A>;
+type OrderedPath<T> = { [F in FieldPath<T>]: Exclude<PathValue<T, F>, null> extends number | string ? F : never; }[FieldPath<T>];
+/**
+ * Makes conditions for a resource with the data type `Data` and the value type
+ * `Value`, and a principal with the type `P`.
+ *
+ * @stability stable
+ * @category models
+ * @since 0.3.0
+ */
+export interface Builder<Data, Value, P> {
+  /** The field is equal to the value. */
+  readonly eq: <const F extends FieldPath<Data>>(field: F, value: OperandOf<PathValue<Data, F>>) => Condition;
+  /** The field is not equal to the value. */
+  readonly ne: <const F extends FieldPath<Data>>(field: F, value: OperandOf<PathValue<Data, F>>) => Condition;
+  readonly lt: <const F extends OrderedPath<Data>>(field: F, value: OperandOf<Exclude<PathValue<Data, F>, null>>) => Condition;
+  readonly lte: <const F extends OrderedPath<Data>>(field: F, value: OperandOf<Exclude<PathValue<Data, F>, null>>) => Condition;
+  readonly gt: <const F extends OrderedPath<Data>>(field: F, value: OperandOf<Exclude<PathValue<Data, F>, null>>) => Condition;
+  readonly gte: <const F extends OrderedPath<Data>>(field: F, value: OperandOf<Exclude<PathValue<Data, F>, null>>) => Condition;
+  /** The field is equal to one of the values. */
+  readonly in: <const F extends FieldPath<Data>>(field: F, values: ReadonlyArray<OperandOf<PathValue<Data, F>>>) => Condition;
+  /** The field has a value that is not `null`. */
+  readonly exists: <const F extends FieldPath<Data>>(field: F) => Condition;
+  /** The path of the resource starts with these parts. */
+  readonly under: (...prefix: ReadonlyArray<string | null | Ref<string | null>>) => Condition;
+  /** A field of the principal, to use as a value. */
+  readonly principal: <const F extends FieldPath<P>>(field: F) => Ref<PathValue<P, F>>;
+  readonly and: <const Cs extends ReadonlyArray<Any>>(...conditions: Cs) => Condition<Error<Cs[number]>, Services<Cs[number]>, OpaqueOf<Cs[number]>>;
+  readonly or: <const Cs extends ReadonlyArray<Any>>(...conditions: Cs) => Condition<Error<Cs[number]>, Services<Cs[number]>, OpaqueOf<Cs[number]>>;
+  readonly not: <C extends Any>(condition: C) => Condition<Error<C>, Services<C>, OpaqueOf<C>>;
+  /**
+   * A test that runs any code. It may give a boolean or an `Effect`. A
+   * condition with a predicate can not become JSON or a query.
+   */
+  readonly predicate: <E = never, R = never>(name: string, test: (value: Value, principal: P) => boolean | Effect.Effect<boolean, E, R>) => Condition<E, R, Opaque>;
+}
+/**
+ * Makes a builder. Rules give you a builder with the right types, so you do not
+ * often need this.
+ *
+ * @stability stable
+ * @category constructors
+ * @since 0.3.0
+ */
+export declare const builder: <Data, Value, P>() => Builder<Data, Value, P>;
+/**
+ * Always true.
+ *
+ * @stability stable
+ * @category constructors
+ * @since 0.3.0
+ */
+export declare const always: Condition;
+/**
+ * Always false.
+ *
+ * @stability stable
+ * @category constructors
+ * @since 0.3.0
+ */
+export declare const never: Condition;
+/**
+ * True when all the conditions are true. With no conditions, it is true.
+ *
+ * @stability stable
+ * @category combinators
+ * @since 0.3.0
+ */
+export declare const and: <const Cs extends ReadonlyArray<Any>>(...conditions: Cs) => Condition<Error<Cs[number]>, Services<Cs[number]>, OpaqueOf<Cs[number]>>;
+/**
+ * True when one of the conditions is true. With no conditions, it is false.
+ *
+ * @stability stable
+ * @category combinators
+ * @since 0.3.0
+ */
+export declare const or: <const Cs extends ReadonlyArray<Any>>(...conditions: Cs) => Condition<Error<Cs[number]>, Services<Cs[number]>, OpaqueOf<Cs[number]>>;
+/**
+ * @stability stable
+ * @category combinators
+ * @since 0.3.0
+ */
+export declare const not: <C extends Any>(condition: C) => Condition<Error<C>, Services<C>, OpaqueOf<C>>;
+/**
+ * The data that a condition needs for a test.
+ *
+ * @stability stable
+ * @category models
+ * @since 0.3.0
+ */
+export interface Input {
+  /** The resource value. */
+  readonly value: object;
+  /**
+   * The principal. Without it, a principal field has no value. See
+   * {@link PrincipalRef}.
+   */
+  readonly principal?: object | undefined;
+  /** The path of the resource. Without it, `Under` is false. */
+  readonly path?: ReadonlyArray<PathSegment> | undefined;
+}
+/**
+ * Tests a condition on a value. A predicate may fail with its error.
+ *
+ * @stability stable
+ * @category evaluation
+ * @since 0.3.0
+ */
+export declare const evaluate: {
+  (input: Input): <E, R, O>(condition: Condition<E, R, O>) => Effect.Effect<boolean, E, R>;
+  <E, R, O>(condition: Condition<E, R, O>, input: Input): Effect.Effect<boolean, E, R>;
+};
+/**
+ * Tests a condition with no predicate on a value, at once.
+ *
+ * @stability stable
+ * @category evaluation
+ * @since 0.3.0
+ */
+export declare const evaluateSync: {
+  (input: Input): (condition: Condition) => boolean;
+  (condition: Condition, input: Input): boolean;
+};
+/**
+ * Puts the principal into a condition and expands `Under` with the path of the
+ * resource. The result is simplified. It has no principal fields and no
+ * `Under` nodes. It is `True` or `False` when the answer does not depend on the
+ * resource value.
+ *
+ * @stability stable
+ * @category evaluation
+ * @since 0.3.0
+ */
+export declare const partial: {
+  (input: {
+    readonly principal?: object | undefined;
+    readonly path?: ReadonlyArray<PathSegment> | undefined;
+  }): <E, R, O>(condition: Condition<E, R, O>) => Condition<E, R, O>;
+  <E, R, O>(condition: Condition<E, R, O>, input: {
+    readonly principal?: object | undefined;
+    readonly path?: ReadonlyArray<PathSegment> | undefined;
+  }): Condition<E, R, O>;
+};
+/**
+ * Makes a condition smaller without a change to its meaning. It removes `True`
+ * and `False` from `And` and `Or`, joins nested `And` and `Or` nodes, and
+ * removes double `Not` nodes.
+ *
+ * @stability stable
+ * @category evaluation
+ * @since 0.3.0
+ */
+export declare const simplify: <E, R, O>(condition: Condition<E, R, O>) => Condition<E, R, O>;
+/**
+ * The functions that change each node of a condition into another form, such
+ * as a database query.
+ *
+ * @stability stable
+ * @category models
+ * @since 0.3.0
+ */
+export interface Interpreter<A> {
+  readonly true: () => A;
+  readonly false: () => A;
+  readonly compare: (op: CompareOperator, field: string, value: Scalar) => A;
+  readonly in: (field: string, values: ReadonlyArray<Scalar>) => A;
+  readonly exists: (field: string) => A;
+  readonly and: (conditions: ReadonlyArray<A>) => A;
+  readonly or: (conditions: ReadonlyArray<A>) => A;
+  readonly not: (condition: A) => A;
+  /** Optional. Without it, a predicate makes `fold` fail. */
+  readonly predicate?: (name: string) => A;
+}
+/**
+ * The error when `fold` can not change a node.
+ *
+ * @stability stable
+ * @category errors
+ * @since 0.3.0
+ */
+export declare const Untranslatable: typeof Untranslatable$1;
+/**
+ * @stability stable
+ * @category errors
+ * @since 0.3.0
+ */
+export type Untranslatable = Untranslatable$1;
+/**
+ * Changes a condition into another form with an interpreter. Call
+ * {@link partial} first: `fold` fails on principal fields and on `Under`
+ * nodes, and on predicates when the interpreter has no `predicate` function.
+ *
+ * @stability stable
+ * @category converting
+ * @since 0.3.0
+ */
+export declare const fold: {
+  <A>(interpreter: Interpreter<A>): (condition: Any) => Effect.Effect<A, Untranslatable>;
+  <A>(condition: Any, interpreter: Interpreter<A>): Effect.Effect<A, Untranslatable>;
+};
+/**
+ * The fields that a condition uses.
+ *
+ * @stability stable
+ * @category getters
+ * @since 0.3.0
+ */
+export declare const fields: (condition: Any) => ReadonlyArray<string>;
+/**
+ * The JSON form of a condition with no predicate.
+ *
+ * @stability stable
+ * @category models
+ * @since 0.3.0
+ */
+export type Encoded = Exclude<Ast, Predicate | And | Or | Not> | EncodedAnd | EncodedOr | EncodedNot;
+/**
+ * @stability stable
+ * @category models
+ * @since 0.3.0
+ */
+export interface EncodedAnd {
+  readonly _tag: "And";
+  readonly conditions: ReadonlyArray<Encoded>;
+}
+/**
+ * @stability stable
+ * @category models
+ * @since 0.3.0
+ */
+export interface EncodedOr {
+  readonly _tag: "Or";
+  readonly conditions: ReadonlyArray<Encoded>;
+}
+/**
+ * @stability stable
+ * @category models
+ * @since 0.3.0
+ */
+export interface EncodedNot {
+  readonly _tag: "Not";
+  readonly condition: Encoded;
+}
+/**
+ * The Schema of a condition with no predicate. It checks the shape only. Use
+ * `Policy.schema` to check the field names against a domain too.
+ *
+ * @stability stable
+ * @category schemas
+ * @since 0.3.0
+ */
+export declare const schema: Schema.Codec<Condition, Encoded>;
+export { Condition_d_exports };
+//# sourceMappingURL=Condition.d.ts.map

package/dist/Condition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Condition.d.ts","names":["Resource.PathSegment","internal.Untranslatable"],"sources":["../src/Condition.ts"],"mappings":"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"}

package/dist/Condition.js

@@ -0,0 +1,141 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { Untranslatable as Untranslatable$1, always as always$1, and as and$1, builder as builder$1, evaluate as evaluate$1, evaluateSync as evaluateSync$1, fields as fields$1, fold as fold$1, never as never$1, not as not$1, or as or$1, partial as partial$1, schema as schema$1, simplify as simplify$1 } from "./internal/condition.js";
+// src/Condition.ts
+var Condition_exports = /* @__PURE__ */ __exportAll({
+	Untranslatable: () => Untranslatable,
+	always: () => always,
+	and: () => and,
+	builder: () => builder,
+	evaluate: () => evaluate,
+	evaluateSync: () => evaluateSync,
+	fields: () => fields,
+	fold: () => fold,
+	never: () => never,
+	not: () => not,
+	or: () => or,
+	partial: () => partial,
+	schema: () => schema,
+	simplify: () => simplify
+});
+/**
+* Makes a builder. Rules give you a builder with the right types, so you do not
+* often need this.
+*
+* @stability stable
+* @category constructors
+* @since 0.3.0
+*/
+const builder = builder$1;
+/**
+* Always true.
+*
+* @stability stable
+* @category constructors
+* @since 0.3.0
+*/
+const always = always$1;
+/**
+* Always false.
+*
+* @stability stable
+* @category constructors
+* @since 0.3.0
+*/
+const never = never$1;
+/**
+* True when all the conditions are true. With no conditions, it is true.
+*
+* @stability stable
+* @category combinators
+* @since 0.3.0
+*/
+const and = and$1;
+/**
+* True when one of the conditions is true. With no conditions, it is false.
+*
+* @stability stable
+* @category combinators
+* @since 0.3.0
+*/
+const or = or$1;
+/**
+* @stability stable
+* @category combinators
+* @since 0.3.0
+*/
+const not = not$1;
+/**
+* Tests a condition on a value. A predicate may fail with its error.
+*
+* @stability stable
+* @category evaluation
+* @since 0.3.0
+*/
+const evaluate = evaluate$1;
+/**
+* Tests a condition with no predicate on a value, at once.
+*
+* @stability stable
+* @category evaluation
+* @since 0.3.0
+*/
+const evaluateSync = evaluateSync$1;
+/**
+* Puts the principal into a condition and expands `Under` with the path of the
+* resource. The result is simplified. It has no principal fields and no
+* `Under` nodes. It is `True` or `False` when the answer does not depend on the
+* resource value.
+*
+* @stability stable
+* @category evaluation
+* @since 0.3.0
+*/
+const partial = partial$1;
+/**
+* Makes a condition smaller without a change to its meaning. It removes `True`
+* and `False` from `And` and `Or`, joins nested `And` and `Or` nodes, and
+* removes double `Not` nodes.
+*
+* @stability stable
+* @category evaluation
+* @since 0.3.0
+*/
+const simplify = simplify$1;
+/**
+* The error when `fold` can not change a node.
+*
+* @stability stable
+* @category errors
+* @since 0.3.0
+*/
+const Untranslatable = Untranslatable$1;
+/**
+* Changes a condition into another form with an interpreter. Call
+* {@link partial} first: `fold` fails on principal fields and on `Under`
+* nodes, and on predicates when the interpreter has no `predicate` function.
+*
+* @stability stable
+* @category converting
+* @since 0.3.0
+*/
+const fold = fold$1;
+/**
+* The fields that a condition uses.
+*
+* @stability stable
+* @category getters
+* @since 0.3.0
+*/
+const fields = fields$1;
+/**
+* The Schema of a condition with no predicate. It checks the shape only. Use
+* `Policy.schema` to check the field names against a domain too.
+*
+* @stability stable
+* @category schemas
+* @since 0.3.0
+*/
+const schema = schema$1;
+export { Condition_exports, Untranslatable, always, and, builder, evaluate, evaluateSync, fields, fold, never, not, or, partial, schema, simplify };
+
+//# sourceMappingURL=Condition.js.map