feat: add minSize/maxSize bound nodes for File size validation

Author: ooospooky

ark/schema/index.ts

@@ -14,8 +14,10 @@ export * from "./refinements/exactLength.ts"
 export * from "./refinements/kinds.ts"
 export * from "./refinements/max.ts"
 export * from "./refinements/maxLength.ts"
+export * from "./refinements/maxSize.ts"
 export * from "./refinements/min.ts"
 export * from "./refinements/minLength.ts"
+export * from "./refinements/minSize.ts"
 export * from "./refinements/pattern.ts"
 export * from "./refinements/range.ts"
 export * from "./roots/domain.ts"

ark/schema/intrinsic.ts

@@ -1,3 +1,4 @@
+import { FileConstructor } from "@ark/util"
 import { node, schemaScope } from "./scope.ts"
 import { $ark } from "./shared/registry.ts"
 import { arrayIndexSource } from "./structure/shared.ts"
@@ -18,7 +19,8 @@ const intrinsicBases = schemaScope(
 		unknown: {},
 		undefined: { unit: undefined },
 		Array,
-		Date
+		Date,
+		File: FileConstructor
 	},
 	{ prereducedAliases: true }
 ).export()

ark/schema/refinements/kinds.ts

@@ -5,8 +5,10 @@ import { Before } from "./before.ts"
 import { ExactLength } from "./exactLength.ts"
 import { Max } from "./max.ts"
 import { MaxLength } from "./maxLength.ts"
+import { MaxSize } from "./maxSize.ts"
 import { Min } from "./min.ts"
 import { MinLength } from "./minLength.ts"
+import { MinSize } from "./minSize.ts"
 
 export interface BoundDeclarations {
 	min: Min.Declaration
@@ -16,6 +18,8 @@ export interface BoundDeclarations {
 	exactLength: ExactLength.Declaration
 	after: After.Declaration
 	before: Before.Declaration
+	minSize: MinSize.Declaration
+	maxSize: MaxSize.Declaration
 }
 
 export interface BoundNodesByKind {
@@ -26,6 +30,8 @@ export interface BoundNodesByKind {
 	exactLength: ExactLength.Node
 	after: After.Node
 	before: Before.Node
+	minSize: MinSize.Node
+	maxSize: MaxSize.Node
 }
 
 export type BoundKind = keyof BoundDeclarations
@@ -43,7 +49,9 @@ export const boundImplementationsByKind: boundImplementationsByKind = {
 	maxLength: MaxLength.implementation,
 	exactLength: ExactLength.implementation,
 	after: After.implementation,
-	before: Before.implementation
+	before: Before.implementation,
+	minSize: MinSize.implementation,
+	maxSize: MaxSize.implementation
 }
 
 export const boundClassesByKind: Record<BoundKind, typeof BaseConstraint<any>> =
@@ -54,5 +62,7 @@ export const boundClassesByKind: Record<BoundKind, typeof BaseConstraint<any>> =
 		maxLength: MaxLength.Node,
 		exactLength: ExactLength.Node,
 		after: After.Node,
-		before: Before.Node
+		before: Before.Node,
+		minSize: MinSize.Node,
+		maxSize: MaxSize.Node
 	}

ark/schema/refinements/maxSize.ts

@@ -0,0 +1,93 @@
+import { describeCollapsibleSize } from "@ark/util"
+import type { BaseRoot } from "../roots/root.ts"
+import type { BaseErrorContext, declareNode } from "../shared/declare.ts"
+import { Disjoint } from "../shared/disjoint.ts"
+import {
+	implementNode,
+	type nodeImplementationOf
+} from "../shared/implement.ts"
+import type { JsonSchema } from "../shared/jsonSchema.ts"
+import { $ark } from "../shared/registry.ts"
+import type { ToJsonSchema } from "../shared/toJsonSchema.ts"
+import type { TraverseAllows } from "../shared/traversal.ts"
+import {
+	BaseRange,
+	createSizeRuleParser,
+	parseExclusiveKey,
+	type BaseRangeInner,
+	type UnknownExpandedRangeSchema
+} from "./range.ts"
+
+export declare namespace MaxSize {
+	export interface Inner extends BaseRangeInner {
+		rule: number
+		exclusive?: true
+	}
+
+	export interface NormalizedSchema extends UnknownExpandedRangeSchema {
+		rule: number
+	}
+
+	export type Schema = NormalizedSchema | number
+
+	export interface ErrorContext extends BaseErrorContext<"maxSize">, Inner {}
+
+	export interface Declaration
+		extends declareNode<{
+			kind: "maxSize"
+			schema: Schema
+			normalizedSchema: NormalizedSchema
+			inner: Inner
+			prerequisite: File
+			errorContext: ErrorContext
+		}> {}
+
+	export type Node = MaxSizeNode
+}
+
+const implementation: nodeImplementationOf<MaxSize.Declaration> =
+	implementNode<MaxSize.Declaration>({
+		kind: "maxSize",
+		collapsibleKey: "rule",
+		hasAssociatedError: true,
+		keys: {
+			rule: { parse: createSizeRuleParser("maxSize") },
+			exclusive: parseExclusiveKey
+		},
+		normalize: schema =>
+			typeof schema === "number" ? { rule: schema } : schema,
+		defaults: {
+			description: node => {
+				if (node.rule === 0)
+					return node.exclusive ? "negative size" : "non-positive size"
+				const limit = describeCollapsibleSize(node.rule)
+				return `${node.exclusive ? "less than" : "at most"} ${limit}`
+			},
+			actual: data => `${data.size} bytes`
+		},
+		intersections: {
+			maxSize: (l, r) => (l.isStricterThan(r) ? l : r),
+			minSize: (max, min) =>
+				max.overlapsRange(min) ? null : Disjoint.init("range", max, min)
+		}
+	})
+
+export class MaxSizeNode extends BaseRange<MaxSize.Declaration> {
+	readonly impliedBasis: BaseRoot = $ark.intrinsic.File.internal
+
+	readonly expression: string = `${this.comparator} ${describeCollapsibleSize(this.rule)}`
+
+	traverseAllows: TraverseAllows<File> =
+		this.exclusive ?
+			data => data.size < this.rule
+		:	data => data.size <= this.rule
+
+	reduceJsonSchema(base: JsonSchema, ctx: ToJsonSchema.Context): JsonSchema {
+		return ctx.fallback.size({ code: "size", base, maxSize: this.rule })
+	}
+}
+
+export const MaxSize = {
+	implementation,
+	Node: MaxSizeNode
+}

ark/schema/refinements/minSize.ts

@@ -0,0 +1,97 @@
+import { describeCollapsibleSize } from "@ark/util"
+import type { IntersectionNode } from "../roots/intersection.ts"
+import type { BaseRoot } from "../roots/root.ts"
+import type { BaseErrorContext, declareNode } from "../shared/declare.ts"
+import {
+	implementNode,
+	type nodeImplementationOf
+} from "../shared/implement.ts"
+import type { JsonSchema } from "../shared/jsonSchema.ts"
+import { $ark } from "../shared/registry.ts"
+import type { ToJsonSchema } from "../shared/toJsonSchema.ts"
+import type { TraverseAllows } from "../shared/traversal.ts"
+import {
+	BaseRange,
+	createSizeRuleParser,
+	parseExclusiveKey,
+	type BaseRangeInner,
+	type UnknownExpandedRangeSchema
+} from "./range.ts"
+
+export declare namespace MinSize {
+	export interface Inner extends BaseRangeInner {
+		rule: number
+		exclusive?: true
+	}
+
+	export interface NormalizedSchema extends UnknownExpandedRangeSchema {
+		rule: number
+	}
+
+	export type Schema = NormalizedSchema | number
+
+	export interface ErrorContext extends BaseErrorContext<"minSize">, Inner {}
+
+	export interface Declaration
+		extends declareNode<{
+			kind: "minSize"
+			schema: Schema
+			normalizedSchema: NormalizedSchema
+			inner: Inner
+			prerequisite: File
+			reducibleTo: "intersection"
+			errorContext: ErrorContext
+		}> {}
+
+	export type Node = MinSizeNode
+}
+
+const implementation: nodeImplementationOf<MinSize.Declaration> =
+	implementNode<MinSize.Declaration>({
+		kind: "minSize",
+		collapsibleKey: "rule",
+		hasAssociatedError: true,
+		keys: {
+			rule: { parse: createSizeRuleParser("minSize") },
+			exclusive: parseExclusiveKey
+		},
+		reduce: inner =>
+			// a non-exclusive minimum size of zero is trivially satisfied
+			inner.rule === 0 && !inner.exclusive ?
+				($ark.intrinsic.unknown as IntersectionNode)
+			:	undefined,
+		normalize: schema =>
+			typeof schema === "number" ? { rule: schema } : schema,
+		defaults: {
+			description: node => {
+				if (node.rule === 0)
+					return node.exclusive ? "positive size" : "non-negative size"
+				const limit = describeCollapsibleSize(node.rule)
+				return `${node.exclusive ? "more than" : "at least"} ${limit}`
+			},
+			actual: data => `${data.size} bytes`
+		},
+		intersections: {
+			minSize: (l, r) => (l.isStricterThan(r) ? l : r)
+		}
+	})
+
+export class MinSizeNode extends BaseRange<MinSize.Declaration> {
+	readonly impliedBasis: BaseRoot = $ark.intrinsic.File.internal
+
+	readonly expression: string = `${this.comparator} ${describeCollapsibleSize(this.rule)}`
+
+	traverseAllows: TraverseAllows<File> =
+		this.exclusive ?
+			data => data.size > this.rule
+		:	data => data.size >= this.rule
+
+	reduceJsonSchema(base: JsonSchema, ctx: ToJsonSchema.Context): JsonSchema {
+		return ctx.fallback.size({ code: "size", base, minSize: this.rule })
+	}
+}
+
+export const MinSize = {
+	implementation,
+	Node: MinSizeNode
+}

ark/schema/refinements/range.ts

@@ -39,6 +39,7 @@ export abstract class BaseRange<
 	readonly compiledActual: string =
 		this.boundOperandKind === "value" ? `data`
 		: this.boundOperandKind === "length" ? `data.length`
+		: this.boundOperandKind === "size" ? `data.size`
 		: `data.valueOf()`
 	readonly comparator: RelativeComparator = compileComparator(
 		this.kind,
@@ -166,19 +167,22 @@ const negatedComparators = {
 export const boundKindPairsByLower: BoundKindPairsByLower = {
 	min: "max",
 	minLength: "maxLength",
-	after: "before"
+	after: "before",
+	minSize: "maxSize"
 }
 
 type BoundKindPairsByLower = {
 	min: "max"
 	minLength: "maxLength"
 	after: "before"
+	minSize: "maxSize"
 }
 
 type BoundKindPairsByUpper = {
 	max: "min"
 	maxLength: "minLength"
 	before: "after"
+	maxSize: "minSize"
 }
 
 export type pairedRangeKind<kind extends RangeKind> =
@@ -198,12 +202,27 @@ export type NumericallyBoundable = string | number | array
 export type Boundable = NumericallyBoundable | Date
 
 export const parseExclusiveKey: keySchemaDefinitions<
-	Declaration<"min" | "max">
+	Declaration<"min" | "max" | "minSize" | "maxSize">
 >["exclusive"] = {
 	// omit key with value false since it is the default
 	parse: (flag: boolean) => flag || undefined
 }
 
+export type SizeBoundKind = "minSize" | "maxSize"
+
+export const writeInvalidSizeBoundMessage = (
+	kind: SizeBoundKind,
+	limit: number
+): string => `${kind} bound must be a non-negative integer (was ${limit})`
+
+export const createSizeRuleParser =
+	(kind: SizeBoundKind) =>
+	(limit: number): number => {
+		if (!Number.isSafeInteger(limit) || limit < 0)
+			throwParseError(writeInvalidSizeBoundMessage(kind, limit))
+		return limit
+	}
+
 export const createLengthSchemaNormalizer =
 	<kind extends "minLength" | "maxLength">(kind: kind) =>
 	(schema: NodeSchema<kind>): NormalizedSchema<kind> => {
@@ -276,6 +295,8 @@ type OperandKindsByBoundKind = satisfy<
 		maxLength: "length"
 		after: "date"
 		before: "date"
+		minSize: "size"
+		maxSize: "size"
 	}
 >
 
@@ -285,7 +306,9 @@ const operandKindsByBoundKind: OperandKindsByBoundKind = {
 	minLength: "length",
 	maxLength: "length",
 	after: "date",
-	before: "date"
+	before: "date",
+	minSize: "size",
+	maxSize: "size"
 } as const
 
 export const compileComparator = (
@@ -296,7 +319,7 @@ export const compileComparator = (
 		exclusive ? "" : "="
 	}` as const
 
-export type BoundOperandKind = "value" | "length" | "date"
+export type BoundOperandKind = "value" | "length" | "date" | "size"
 
 export type LengthBoundableData = string | array
 
@@ -308,7 +331,7 @@ export const dateLimitToString = (limit: LimitSchemaValue): string =>
 export const writeUnboundableMessage = <root extends string>(
 	root: root
 ): writeUnboundableMessage<root> =>
-	`Bounded expression ${root} must be exactly one of number, string, Array, or Date`
+	`Bounded expression ${root} must be exactly one of number, string, Array, Date, or File`
 
 export type writeUnboundableMessage<root extends string> =
-	`Bounded expression ${root} must be exactly one of number, string, Array, or Date`
+	`Bounded expression ${root} must be exactly one of number, string, Array, Date, or File`

ark/schema/roots/intersection.ts

@@ -215,6 +215,14 @@ const implementation: nodeImplementationOf<Intersection.Declaration> =
 			predicate: {
 				child: true,
 				parse: constraintKeyParser("predicate")
+			},
+			minSize: {
+				child: true,
+				parse: constraintKeyParser("minSize")
+			},
+			maxSize: {
+				child: true,
+				parse: constraintKeyParser("maxSize")
 			}
 		},
 		// leverage reduction logic from intersection and identity to ensure initial

ark/schema/shared/implement.ts

@@ -55,7 +55,9 @@ export const prestructuralKinds = [
 	"maxLength",
 	"minLength",
 	"before",
-	"after"
+	"after",
+	"maxSize",
+	"minSize"
 ] as const
 
 export type PrestructuralKind = (typeof prestructuralKinds)[number]