@nmnmcc/ability 2.1.2 → 2.1.3

package/src/Policy.ts

@@ -280,6 +280,17 @@ export type CheckField<D, T> = T extends { readonly field?: infer F }
 			}
 	: unknown
 
+/**
+ * A target or a request with its field checked, as {@link CheckField} does.
+ * Each member of a union is checked by itself, so a member with no field
+ * does not take the place of the check of another member.
+ *
+ * @stability stable
+ * @category utility types
+ * @since 2.1.3
+ */
+export type Checked<D, T> = T extends unknown ? T & CheckField<D, T> : never
+
 /**
  * A request: a principal, an action, and a resource value.
  *
@@ -804,7 +815,7 @@ export const decide: <
 	const Req extends DeepRequest<NoInfer<D>>,
 >(
 	policy: Policy<D, X>,
-	request: Req & CheckField<NoInfer<D>, Req>,
+	request: Checked<NoInfer<D>, Req>,
 ) => Effect.Effect<
 	Decision.Decision,
 	Condition.ErrorOf<X>,
@@ -823,7 +834,7 @@ export const decideSync: <
 	const Req extends DeepRequest<NoInfer<D>>,
 >(
 	policy: Policy<D>,
-	request: Req & CheckField<NoInfer<D>, Req>,
+	request: Checked<NoInfer<D>, Req>,
 ) => Decision.Decision = Decide.decideSync
 
 /**
@@ -842,7 +853,7 @@ export const explain: <
 	const Req extends DeepRequest<NoInfer<D>>,
 >(
 	policy: Policy<D, X>,
-	request: Req & CheckField<NoInfer<D>, Req>,
+	request: Checked<NoInfer<D>, Req>,
 ) => Effect.Effect<Explanation, Condition.ErrorOf<X>, Condition.ServicesOf<X>> =
 	Decide.explain as never
 
@@ -923,7 +934,7 @@ export const residual: <
 	const Req extends DeepKindRequest<NoInfer<D>>,
 >(
 	policy: Policy<D, X>,
-	request: Req & CheckField<NoInfer<D>, Req>,
+	request: Checked<NoInfer<D>, Req>,
 ) => Condition.Condition<ResidualReads<D, Req["kind"]>, X> =
 	Analysis.residual as never
 
@@ -985,7 +996,7 @@ export const coverage: <
 	const Req extends DeepKindRequest<NoInfer<D>>,
 >(
 	policy: Policy<D, X>,
-	request: Req & CheckField<NoInfer<D>, Req>,
+	request: Checked<NoInfer<D>, Req>,
 ) => Coverage<ResidualReads<D, Req["kind"]>, X> = Analysis.coverageAny as never
 
 // Schema

package/src/internal/algebra.ts

@@ -655,25 +655,29 @@ export const provide = (node: Node, context: Context.Context<never>): Node =>
 
 /** The fields that a condition tests, in the order that they first come. */
 export const fields = (node: Node): ReadonlyArray<string> => {
-	const all = Trampoline.run(node.depth, (R) => {
-		const go = (current: Node): Step<ReadonlyArray<string>> => {
+	// The fields go into one native `Set`, in order, as in `dedupe`: a field
+	// of a condition that is not bound to a domain may be any string. A walk
+	// that joined the lists of the children would copy the list of a deep
+	// condition at each level. The set belongs to this walk.
+	const seen = new Set<string>()
+	Trampoline.run(node.depth, (R) => {
+		const go = (current: Node): Step<undefined> => {
 			switch (current._tag) {
 				case "Compare":
 				case "In":
 				case "Exists":
-					return R.succeed([current.field])
+					seen.add(current.field)
+					return R.succeed(undefined)
 				case "And":
 				case "Or":
-					return R.map(eachChild(R, current.conditions, go), Arr.flatten)
+					return R.map(eachChild(R, current.conditions, go), () => undefined)
 				case "Not":
 					return R.suspend(() => go(current.condition))
 				default:
-					return R.succeed([])
+					return R.succeed(undefined)
 			}
 		}
 		return go(node)
 	})
-	// A native `Set`, as in `dedupe`: a field of a condition that is not bound
-	// to a domain may be any string.
-	return Array.from(new Set(all))
+	return Array.from(seen)
 }

package/src/internal/authorizer.ts

@@ -139,43 +139,58 @@ class PrincipalKey implements Equal.Equal {
  * the order that a loop sees them. `Equal` does not see the order of the
  * fields of an object or of the items of a map, but a loader may read it, as
  * `Object.values` does. So two keys need the same order too. A scalar is in
- * the text with its type, so the items of a set or a map show their order.
+ * the text with its type, so the items of a set or a map show their order,
+ * and `-0` is not `0`: `Equal` takes them as one, but a loader may not.
+ *
+ * Each object gets a number at its first visit, and a later visit of it, as
+ * of a part that the value shares or of a loop back to a part above, writes
+ * `#` and the number. So the walk ends for a value with a loop, and a shared
+ * part does not make the text very long. The numbers are in a native `Map`,
+ * because the walk must find an object by the object itself. The map belongs
+ * to one walk.
  */
-const orderOf: (value: unknown) => string = Trampoline.adaptive<
-	unknown,
-	string
->((R, child) => (value, depth) => {
-	if (typeof value !== "object" || value === null) {
-		return R.succeed(
-			typeof value === "string"
-				? JSON.stringify(value)
-				: `${typeof value}:${String(value)}`,
-		)
-	}
-	const items = (list: ReadonlyArray<unknown>) =>
-		R.forEach(list, (item) => child(item, depth + 1))
-	if (Array.isArray(value)) {
-		return R.map(items(value), (texts) => `[${texts.join(",")}]`)
-	}
-	if (
-		value instanceof Map ||
-		value instanceof Set ||
-		HashMap.isHashMap(value) ||
-		HashSet.isHashSet(value) ||
-		Chunk.isChunk(value)
-	) {
+const orderOf = (root: unknown): string => {
+	const ids = new Map<object, number>()
+	return Trampoline.adaptive<unknown, string>((R, child) => (value, depth) => {
+		if (typeof value !== "object" || value === null) {
+			return R.succeed(
+				typeof value === "string"
+					? JSON.stringify(value)
+					: Object.is(value, -0)
+						? "number:-0"
+						: `${typeof value}:${String(value)}`,
+			)
+		}
+		const known = ids.get(value)
+		if (known !== undefined) {
+			return R.succeed(`#${String(known)}`)
+		}
+		ids.set(value, ids.size)
+		const items = (list: ReadonlyArray<unknown>) =>
+			R.forEach(list, (item) => child(item, depth + 1))
+		if (Array.isArray(value)) {
+			return R.map(items(value), (texts) => `[${texts.join(",")}]`)
+		}
+		if (
+			value instanceof Map ||
+			value instanceof Set ||
+			HashMap.isHashMap(value) ||
+			HashSet.isHashSet(value) ||
+			Chunk.isChunk(value)
+		) {
+			return R.map(
+				items(Array.from(value as Iterable<unknown>)),
+				(texts) => `<${texts.join(",")}>`,
+			)
+		}
+		const names = Object.keys(value)
 		return R.map(
-			items(Array.from(value as Iterable<unknown>)),
-			(texts) => `<${texts.join(",")}>`,
+			items(Arr.map(names, (name) => (value as Record<string, unknown>)[name])),
+			(texts) =>
+				`{${Arr.map(names, (name, index) => `${JSON.stringify(name)}:${texts[index]!}`).join(",")}}`,
 		)
-	}
-	const names = Object.keys(value)
-	return R.map(
-		items(Arr.map(names, (name) => (value as Record<string, unknown>)[name])),
-		(texts) =>
-			`{${Arr.map(names, (name, index) => `${JSON.stringify(name)}:${texts[index]!}`).join(",")}}`,
-	)
-})
+	})(root)
+}
 
 /**
  * Gives the JSON codec of a Schema, or `undefined` when the Schema has no JSON

package/src/internal/bind.ts

@@ -815,48 +815,46 @@ export const treeIssues = (
 	// shares the path of its parent. The tree may be the JSON form, with no
 	// depth that a node knows, so the walk is a walk of the trampoline for an
 	// input of an unknown depth.
-	type Found = Issue | readonly [RuleData, Place.Place]
+	// The rules go into one list, in order: a walk that joined the lists of
+	// the children at each node would copy the list of a deep tree at each
+	// level. The list belongs to this walk.
+	const found: Array<readonly [RuleData, Place.Place]> = []
 	const rulesOf = Trampoline.adaptive<
 		{ readonly node: TreeNode; readonly at: At },
-		ReadonlyArray<Found>
+		undefined
 	>((R, child) => ({ node, at }, level) => {
+		const below = (
+			parts: ReadonlyArray<{ readonly node: TreeNode; readonly at: At }>,
+		) =>
+			R.map(
+				R.forEach(parts, (part) => child(part, level + 1)),
+				() => undefined,
+			)
 		switch (node._tag) {
 			case "Rules":
-				return R.succeed(
-					Arr.map(
-						node.rules,
-						(rule, index) => [rule, Place.at(at, "rules", index)] as const,
-					),
-				)
+				Arr.forEach(node.rules, (rule, index) => {
+					found.push([rule, Place.at(at, "rules", index)])
+				})
+				return R.succeed(undefined)
 			case "All":
 			case "Any":
 			case "FirstOf":
-				return R.map(
-					R.forEach(node.policies, (inner, index) =>
-						child(
-							{ node: inner, at: Place.at(at, "policies", index) },
-							level + 1,
-						),
-					),
-					Arr.flatten,
+				return below(
+					Arr.map(node.policies, (inner, index) => ({
+						node: inner,
+						at: Place.at(at, "policies", index),
+					})),
 				)
 			case "Ceiling":
-				return R.map(
-					R.forEach(
-						[
-							{ node: node.cap, at: Place.at(at, "cap") },
-							{ node: node.policy, at: Place.at(at, "policy") },
-						],
-						(part) => child(part, level + 1),
-					),
-					Arr.flatten,
-				)
+				return below([
+					{ node: node.cap, at: Place.at(at, "cap") },
+					{ node: node.policy, at: Place.at(at, "policy") },
+				])
 		}
 	})
+	rulesOf({ node: root, at: undefined })
 	const memo = makeMemo(domain.limits)
-	return Arr.flatMap(rulesOf({ node: root, at: undefined }), (found) =>
-		Array.isArray(found)
-			? ruleIssues(domain, found[0], found[1], memo)
-			: [found as Issue],
+	return Arr.flatMap(found, ([rule, place]) =>
+		ruleIssues(domain, rule, place, memo),
 	)
 }

package/src/internal/catalog.ts

@@ -272,13 +272,30 @@ const structOf = (ast: SchemaAST.AST): SchemaAST.Objects | undefined =>
 const hasCheck = (
 	checks: ReadonlyArray<SchemaAST.Check<never>>,
 	id: string,
-): boolean =>
-	Arr.some(
-		checks,
-		(check) =>
-			check.annotations?.representation?.id === id ||
-			(check._tag === "FilterGroup" && hasCheck(check.checks, id)),
-	)
+): boolean => hasCheckIn({ checks, id })
+
+/**
+ * The walk of {@link hasCheck}. A group of checks may hold a group, very many
+ * levels down, as `.and(...)` many times makes, so it is a walk of the
+ * trampoline for an input of an unknown depth.
+ */
+const hasCheckIn = Trampoline.adaptive<
+	{
+		readonly checks: ReadonlyArray<SchemaAST.Check<never>>
+		readonly id: string
+	},
+	boolean
+>(
+	(R, child) =>
+		({ checks, id }, depth) =>
+			R.some(checks, (check) =>
+				check.annotations?.representation?.id === id
+					? R.succeed(true)
+					: check._tag === "FilterGroup"
+						? child({ checks: check.checks, id }, depth + 1)
+						: R.succeed(false),
+			),
+)
 
 /** A struct with named fields, or with the keys of a record. */
 const isStruct = (

package/src/internal/policy-nodes.ts

@@ -196,29 +196,35 @@ export const isNode = (u: unknown): u is Node => u instanceof Base
  * into the condition of each rule takes the rules from this list first, so it
  * does not go down the levels of the tree and of a condition at once.
  */
-export const rulesOf = (root: Node): ReadonlyArray<Rule.Rule> =>
+export const rulesOf = (root: Node): ReadonlyArray<Rule.Rule> => {
+	// The rules go into one list, in order. A walk that joined the lists of
+	// the children at each node would copy the list of a deep tree at each
+	// level. The list belongs to this walk.
+	const rules: Array<Rule.Rule> = []
 	// The walk takes the steps of a trampoline, so a deep tree does not fill
 	// the stack.
 	Trampoline.run(root.depth, (R) => {
-		const go = (node: Node): Trampoline.Step<ReadonlyArray<Rule.Rule>> => {
+		const children = (nodes: ReadonlyArray<Node>) =>
+			R.map(
+				R.forEach(nodes, (child) => R.suspend(() => go(child))),
+				() => undefined,
+			)
+		const go = (node: Node): Trampoline.Step<undefined> => {
 			switch (node._tag) {
 				case "Rules":
-					return R.succeed(node.rules)
+					Arr.forEach(node.rules, (rule) => {
+						rules.push(rule)
+					})
+					return R.succeed(undefined)
 				case "All":
 				case "Any":
 				case "FirstOf":
-					return R.map(
-						R.forEach(node.policies, (child) => R.suspend(() => go(child))),
-						Arr.flatten,
-					)
+					return children(node.policies)
 				case "Ceiling":
-					return R.map(
-						R.forEach([node.cap, node.policy], (child) =>
-							R.suspend(() => go(child)),
-						),
-						Arr.flatten,
-					)
+					return children([node.cap, node.policy])
 			}
 		}
 		return go(root)
 	})
+	return rules
+}

package/src/internal/search.ts

@@ -317,28 +317,35 @@ const fix = (root: Node, field: string, value: unknown, search: Search): Node =>
 	})
 
 /** The fields of the tests of a condition, once for each test. */
-const testedFields = (root: Node): ReadonlyArray<string> =>
+const testedFields = (root: Node): ReadonlyArray<string> => {
+	// The fields go into one list, in order. A walk that joined the lists of
+	// the children would copy the list of a deep condition at each level. The
+	// list belongs to this walk.
+	const fields: Array<string> = []
 	Trampoline.run(root.depth, (R) => {
-		const go = (node: Node): Trampoline.Step<ReadonlyArray<string>> => {
+		const go = (node: Node): Trampoline.Step<undefined> => {
 			switch (node._tag) {
 				case "Compare":
 				case "In":
 				case "Exists":
-					return R.succeed([node.field])
+					fields.push(node.field)
+					return R.succeed(undefined)
 				case "And":
 				case "Or":
 					return R.map(
 						R.forEach(node.conditions, (child) => R.suspend(() => go(child))),
-						Arr.flatten,
+						() => undefined,
 					)
 				case "Not":
 					return R.suspend(() => go(node.condition))
 				default:
-					return R.succeed([])
+					return R.succeed(undefined)
 			}
 		}
 		return go(root)
 	})
+	return fields
+}
 
 /**
  * Picks the next field to split on. A field comes before the fields below it,
@@ -486,20 +493,29 @@ const exampleOf = (
  * belongs to one search.
  */
 const constantsOf = (node: Node): Map<string, Set<Nodes.Scalar>> => {
-	type Pair = readonly [string, ReadonlyArray<Nodes.Scalar>]
+	// The constants go into one map as the walk finds them. A walk that
+	// joined the lists of the children would copy the list of a deep
+	// condition at each level. The map belongs to one search.
+	const all = new Map<string, Set<Nodes.Scalar>>()
+	const add = (field: string, values: ReadonlyArray<Nodes.Scalar>): void => {
+		const known = all.get(field) ?? new Set<Nodes.Scalar>()
+		Arr.forEach(values, (value) => known.add(value))
+		all.set(field, known)
+	}
 	// The walk takes the steps of a trampoline, so a deep condition does not
 	// fill the stack.
-	const pairs = Trampoline.run(node.depth, (R) => {
-		const go = (current: Node): Trampoline.Step<ReadonlyArray<Pair>> => {
+	Trampoline.run(node.depth, (R) => {
+		const go = (current: Node): Trampoline.Step<undefined> => {
 			switch (current._tag) {
 				case "Compare":
-					return R.succeed([[current.field, [literalOf(current.value)]]])
+					add(current.field, [literalOf(current.value)])
+					return R.succeed(undefined)
 				case "In":
-					return R.succeed([
-						[current.field, Arr.map(current.values, literalOf)],
-					])
+					add(current.field, Arr.map(current.values, literalOf))
+					return R.succeed(undefined)
 				case "Exists":
-					return R.succeed([[current.field, []]])
+					add(current.field, [])
+					return R.succeed(undefined)
 				case "Under":
 					throw new Error(
 						"Condition.satisfiable needs a condition with no Under nodes. Call Condition.partial first.",
@@ -510,22 +526,16 @@ const constantsOf = (node: Node): Map<string, Set<Nodes.Scalar>> => {
 						R.forEach(current.conditions, (child) =>
 							R.suspend(() => go(child)),
 						),
-						Arr.flatten,
+						() => undefined,
 					)
 				case "Not":
 					return R.suspend(() => go(current.condition))
 				default:
-					return R.succeed([])
+					return R.succeed(undefined)
 			}
 		}
 		return go(node)
 	})
-	const all = new Map<string, Set<Nodes.Scalar>>()
-	Arr.forEach(pairs, ([field, values]) => {
-		const known = all.get(field) ?? new Set<Nodes.Scalar>()
-		Arr.forEach(values, (value) => known.add(value))
-		all.set(field, known)
-	})
 	return all
 }