@nmnmcc/ability 2.1.2 → 2.1.4

package/src/internal/catalog.ts

@@ -175,12 +175,6 @@ export interface Branch {
 
 /** The catalog of the fields of a Schema. */
 export interface Catalog {
-	/**
-	 * The fields that a list shows, a field before the fields below it. For a
-	 * recursive Schema, the list goes into each recursive place one time on
-	 * each path, so it is finite.
-	 */
-	readonly fields: ReadonlyArray<Field>
 	/** The places, by id. The root is the place with the id 0. */
 	readonly branches: ReadonlyArray<Branch>
 	/**
@@ -272,13 +266,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 = (
@@ -287,6 +298,13 @@ const isStruct = (
 	ast !== undefined &&
 	(ast.propertySignatures.length > 0 || ast.indexSignatures.length > 0)
 
+/** Tests if a Schema holds only values that are not objects, as `bigint`. */
+const isPrimitive = (ast: SchemaAST.AST): boolean =>
+	ast._tag === "BigInt" ||
+	ast._tag === "Symbol" ||
+	ast._tag === "UniqueSymbol" ||
+	(ast._tag === "Literal" && typeof ast.literal === "bigint")
+
 /** The kinds of the values of a Schema that is not a struct. */
 const kindsOf = (ast: SchemaAST.AST): Kinds => {
 	switch (ast._tag) {
@@ -464,6 +482,15 @@ const placeOf = (place: Place): Made => {
 	const valueKinds = Arr.reduce(values, noKinds, (kinds, schema) =>
 		joinKinds(kinds, kindsOf(structOf(schema) ?? schema)),
 	)
+	// A value of a branch may be an object, with parts that the Schema does
+	// not name. A `bigint` or a `symbol` is not a scalar that a test takes,
+	// so its kinds say `object`, but it has no parts: a read below it gives
+	// `null`, as below a string.
+	const objects = Arr.some(
+		values,
+		(schema) =>
+			!isPrimitive(schema) && kindsOf(structOf(schema) ?? schema).object,
+	)
 	const kinds = place.top
 		? anyKinds
 		: joinKinds(
@@ -485,8 +512,7 @@ const placeOf = (place: Place): Made => {
 		// decision may get a value made by hand. A value that may be any
 		// object, as one of `Schema.Unknown` may, may have the name with any
 		// value too.
-		const top =
-			place.top || valueKinds.object || properties.length < structs.length
+		const top = place.top || objects || properties.length < structs.length
 		const below: Place = {
 			schemas: Arr.flatMap(properties, (property) =>
 				alternatives(property.type, new Set()),
@@ -505,8 +531,7 @@ const placeOf = (place: Place): Made => {
 		return [name, below] as const
 	})
 	const signatures = Arr.flatMap(records, (struct) => struct.indexSignatures)
-	const keyTop =
-		place.top || valueKinds.object || records.length < structs.length
+	const keyTop = place.top || objects || records.length < structs.length
 	return {
 		branch: {
 			kinds,
@@ -514,11 +539,7 @@ const placeOf = (place: Place): Made => {
 			structs: structs.length > 0,
 			// A field that is a scalar in one branch of a union and a struct in
 			// another holds parts too.
-			open:
-				records.length > 0 ||
-				structs.length > 0 ||
-				valueKinds.object ||
-				place.top,
+			open: records.length > 0 || structs.length > 0 || objects || place.top,
 			plain: place.plain,
 			key:
 				signatures.length === 0
@@ -634,13 +655,18 @@ const fieldAt = (
  * The fields that a list shows, a field before the fields below it, down to
  * `parts` parts. A path goes into a place that is on it already one time
  * only, so the list of a recursive Schema is finite. The walk keeps a stack
- * of the places to visit, so a deep Schema does not fill the stack. The
- * stack belongs to this walk.
+ * of the places to visit, so a deep Schema does not fill the stack. A Schema
+ * that shares one part in many places may have very many fields, so the
+ * walk counts the fields that it makes, and it stops at the first one past
+ * `most`. The stack and the count belong to this walk.
  */
 const listOf = (
 	branches: ReadonlyArray<Branch>,
 	parts: number,
+	most: number,
+	thing: string,
 ): ReadonlyArray<Field> => {
+	const count = { fields: 0 }
 	interface Visit {
 		readonly branch: Branch
 		readonly path: ReadonlyArray<Segment>
@@ -691,13 +717,14 @@ const listOf = (
 				visit.path.length === 0
 					? []
 					: [fieldAt(visit.branch, visit.path, parts)]
-			if (field.length > 0 && rest.length + 1 > Limits.ceilings.catalogFields) {
+			count.fields += field.length
+			if (count.fields > most) {
 				throw Limits.exceeded(
-					"A Schema",
+					thing,
 					"catalogFields",
 					"fields",
-					rest.length + 1,
-					Limits.ceilings.catalogFields,
+					count.fields,
+					most,
 				)
 			}
 			return Option.some([field, rest] as const)
@@ -706,22 +733,25 @@ const listOf = (
 }
 
 /**
- * The fields that a list shows for paths of at most `parts` parts, as for a
- * domain with that limit. See `Catalog.fields`.
+ * The fields that a list shows, a field before the fields below it, for
+ * paths of at most `parts` parts. For a recursive Schema, the list goes into
+ * each recursive place one time on each path, so it is finite. A list with
+ * more than `most` fields is an error, as for a domain with these limits.
+ * Each call makes the list again: a domain checks its size one time, and a
+ * list of permitted fields reads it.
  */
 export const fieldsOf = (
 	catalog: Catalog,
-	parts: number,
-): ReadonlyArray<Field> =>
-	parts === Limits.fieldPathParts
-		? catalog.fields
-		: listOf(catalog.branches, parts)
+	parts: number = Limits.fieldPathParts,
+	most: number = Limits.ceilings.catalogFields,
+	thing: string = "A Schema",
+): ReadonlyArray<Field> => listOf(catalog.branches, parts, most, thing)
 
 /**
- * Makes the catalog of a Schema, with the list of its fields for the default
- * limit of the parts of a path. It throws when a field name has a dot or is
- * empty, and when the Schema has more places or fields than the ceiling of
- * `catalogFields`. A domain checks the size of the list with its own limit.
+ * Makes the catalog of a Schema. It throws when a field name has a dot or is
+ * empty, and when the Schema has more places than the ceiling of
+ * `catalogFields`. A domain checks the size of the list of the fields with
+ * its own limit: see {@link fieldsOf}.
  */
 export const catalogOf = (ast: SchemaAST.AST): Catalog => {
 	const branches = branchesOf({
@@ -731,7 +761,6 @@ export const catalogOf = (ast: SchemaAST.AST): Catalog => {
 		plain: true,
 	})
 	return {
-		fields: listOf(branches, Limits.fieldPathParts),
 		branches,
 		edges: Arr.reduce(
 			branches,

package/src/internal/decide.ts

@@ -390,7 +390,11 @@ export const permittedFields = (
 	const listed = Arr.filter(
 		// The list for the limit of the parts of a path of the domain, as the
 		// decision of each field reads it.
-		Catalog.fieldsOf(descriptor.catalog, policy.domain.limits.fieldPathParts),
+		Catalog.fieldsOf(
+			descriptor.catalog,
+			policy.domain.limits.fieldPathParts,
+			policy.domain.limits.catalogFields,
+		),
 		(field) =>
 			field.listed &&
 			Arr.every(field.path, (segment) => typeof segment === "string"),

package/src/internal/domain.ts

@@ -21,22 +21,17 @@ class DomainData extends Data.Class<{
 	readonly limits: Limits.Limits
 }> {}
 
-/** Stops a catalog with more fields in its list than the domain takes. */
+/**
+ * Stops a catalog with more fields in its list than the domain takes. The
+ * list stops at the first field past the limit, so a Schema with very many
+ * fields does not take very much memory first.
+ */
 const checkCatalog = (
 	catalog: Catalog.Catalog,
 	limits: Limits.Limits,
 	name: string,
 ): void => {
-	const fields = Catalog.fieldsOf(catalog, limits.fieldPathParts).length
-	if (fields > limits.catalogFields) {
-		throw Limits.exceeded(
-			name,
-			"catalogFields",
-			"fields",
-			fields,
-			limits.catalogFields,
-		)
-	}
+	Catalog.fieldsOf(catalog, limits.fieldPathParts, limits.catalogFields, name)
 }
 
 /**

package/src/internal/policy-json.ts

@@ -287,14 +287,30 @@ const decodeMeta = (
 		(found) =>
 			found === undefined
 				? Effect.void
-				: Effect.mapError(
-						Schema.decodeUnknownEffect(metaCodec(found.schema))(found.value),
-						(error) =>
-							new Json.Problem({
-								path: Place.pathOf(at),
-								message: error.message,
-								issue: error.issue,
-							}),
+				: Schema.decodeUnknownEffect(metaCodec(found.schema))(found.value).pipe(
+						Effect.mapError(
+							(error) =>
+								new Json.Problem({
+									path: Place.pathOf(at),
+									message: error.message,
+									issue: error.issue,
+								}),
+						),
+						// The decoder of a Schema in Effect calls itself for each level of
+						// the value, so a deep value that the budget takes, as 5,000 levels
+						// of a recursive `meta` Schema, fills its stack. That is a defect
+						// of the decoder, not of the policy, so it is a problem of the
+						// input here, and the policy does not load.
+						Effect.catchDefect((defect) =>
+							defect instanceof RangeError
+								? Effect.fail(
+										Json.problemAt(
+											at,
+											"The meta of the rule has too many levels for the Schema of meta",
+										),
+									)
+								: Effect.die(defect),
+						),
 					),
 	)
 }

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
 }