rename isPropertiesLength to isPropertiesLengthBetween

Author: gcanti

packages/effect/src/Schema.ts

@@ -5111,39 +5111,42 @@ export function isMaxProperties(maxProperties: number, annotations?: Annotations
 }
 
 /**
- * Validates that an object contains exactly the specified number of properties.
+ * Validates that an object contains between `minimum` and `maximum` properties (inclusive).
  * This includes both string and symbol keys when counting properties.
  *
  * **JSON Schema**
  *
- * This check corresponds to both `minProperties` and `maxProperties`
- * constraints in JSON Schema, both set to the same value.
+ * This check corresponds to `minProperties` and `maxProperties`
+ * constraints in JSON Schema.
  *
  * **Arbitrary**
  *
- * When generating test data with fast-check, this applies both `minLength` and
+ * When generating test data with fast-check, this applies `minLength` and
  * `maxLength` constraints to the array of entries that is generated before
- * being converted to an object, ensuring the resulting object has exactly the
- * required number of properties.
+ * being converted to an object.
  *
  * @category Object checks
  * @since 4.0.0
  */
-export function isPropertiesLength(length: number, annotations?: Annotations.Filter) {
-  length = Math.max(0, Math.floor(length))
+export function isPropertiesLengthBetween(minimum: number, maximum: number, annotations?: Annotations.Filter) {
+  minimum = Math.max(0, Math.floor(minimum))
+  maximum = Math.max(0, Math.floor(maximum))
   return makeFilter<object>(
-    (input) => Reflect.ownKeys(input).length === length,
+    (input) => Reflect.ownKeys(input).length >= minimum && Reflect.ownKeys(input).length <= maximum,
     {
-      expected: `a value with exactly ${length === 1 ? "1 entry" : `${length} entries`}`,
+      expected: minimum === maximum
+        ? `a value with exactly ${minimum === 1 ? "1 entry" : `${minimum} entries`}`
+        : `a value with between ${minimum} and ${maximum} entries`,
       meta: {
-        _tag: "isPropertiesLength",
-        length
+        _tag: "isPropertiesLengthBetween",
+        minimum,
+        maximum
       },
       [AST.STRUCTURAL_ANNOTATION_KEY]: true,
       toArbitraryConstraint: {
         array: {
-          minLength: length,
-          maxLength: length
+          minLength: minimum,
+          maxLength: maximum
         }
       },
       ...annotations
@@ -9018,9 +9021,10 @@ export declare namespace Annotations {
       readonly _tag: "isMaxProperties"
       readonly maxProperties: number
     }
-    readonly isPropertiesLength: {
-      readonly _tag: "isPropertiesLength"
-      readonly length: number
+    readonly isPropertiesLengthBetween: {
+      readonly _tag: "isPropertiesLengthBetween"
+      readonly minimum: number
+      readonly maximum: number
     }
     readonly isPropertyNames: {
       readonly _tag: "isPropertyNames"

packages/effect/src/SchemaRepresentation.ts

@@ -657,7 +657,7 @@ export type ObjectsMeta =
   | Schema.Annotations.BuiltInMetaDefinitions[
     | "isMinProperties"
     | "isMaxProperties"
-    | "isPropertiesLength"
+    | "isPropertiesLengthBetween"
   ]
   | { readonly _tag: "isPropertyNames"; readonly propertyNames: Representation }
 
@@ -1341,10 +1341,11 @@ const $IsMaxProperties = Schema.Struct({
   maxProperties: NonNegativeInt
 }).annotate({ identifier: "IsMaxProperties" })
 
-const $IsPropertiesLength = Schema.Struct({
-  _tag: Schema.tag("isPropertiesLength"),
-  length: NonNegativeInt
-}).annotate({ identifier: "IsPropertiesLength" })
+const $IsPropertiesLengthBetween = Schema.Struct({
+  _tag: Schema.tag("isPropertiesLengthBetween"),
+  minimum: NonNegativeInt,
+  maximum: NonNegativeInt
+}).annotate({ identifier: "IsPropertiesLengthBetween" })
 
 const $IsPropertyNames = Schema.Struct({
   _tag: Schema.tag("isPropertyNames"),
@@ -1360,7 +1361,7 @@ const $IsPropertyNames = Schema.Struct({
 export const $ObjectsMeta = Schema.Union([
   $IsMinProperties,
   $IsMaxProperties,
-  $IsPropertiesLength,
+  $IsPropertiesLengthBetween,
   $IsPropertyNames
 ]).annotate({ identifier: "ObjectsMeta" })
 
@@ -2059,8 +2060,8 @@ export function toSchema<S extends Schema.Top = Schema.Top>(document: Document,
         return Schema.isMinProperties(filter.meta.minProperties, a)
       case "isMaxProperties":
         return Schema.isMaxProperties(filter.meta.maxProperties, a)
-      case "isPropertiesLength":
-        return Schema.isPropertiesLength(filter.meta.length, a)
+      case "isPropertiesLengthBetween":
+        return Schema.isPropertiesLengthBetween(filter.meta.minimum, filter.meta.maximum, a)
       case "isPropertyNames":
         return Schema.isPropertyNames(recur(filter.meta.propertyNames) as Schema.Record.Key, a)
 
@@ -2686,8 +2687,8 @@ export function toCodeDocument(multiDocument: MultiDocument, options?: {
         return `Schema.isMinProperties(${filter.meta.minProperties}${ca})`
       case "isMaxProperties":
         return `Schema.isMaxProperties(${filter.meta.maxProperties}${ca})`
-      case "isPropertiesLength":
-        return `Schema.isPropertiesLength(${filter.meta.length}${ca})`
+      case "isPropertiesLengthBetween":
+        return `Schema.isPropertiesLengthBetween(${filter.meta.minimum}, ${filter.meta.maximum}${ca})`
       case "isPropertyNames":
         return `Schema.isPropertyNames(${recur(filter.meta.propertyNames).runtime}${ca})`
 

packages/effect/src/internal/schema/representation.ts

@@ -697,8 +697,8 @@ export function toJsonSchemaMultiDocument(
           return { minProperties: meta.minProperties }
         case "isMaxProperties":
           return { maxProperties: meta.maxProperties }
-        case "isPropertiesLength":
-          return { minProperties: meta.length, maxProperties: meta.length }
+        case "isPropertiesLengthBetween":
+          return { minProperties: meta.minimum, maxProperties: meta.maximum }
         case "isPropertyNames":
           return { propertyNames: recur(meta.propertyNames) }
 

packages/effect/test/schema/Schema.test.ts

@@ -1621,8 +1621,8 @@ Expected a value between -2147483648 and 2147483647, got 9007199254740992`
         )
       })
 
-      it("isPropertiesLength", async () => {
-        const schema = Schema.Record(Schema.String, Schema.Number).check(Schema.isPropertiesLength(2))
+      it("isPropertiesLengthBetween", async () => {
+        const schema = Schema.Record(Schema.String, Schema.Number).check(Schema.isPropertiesLengthBetween(2, 2))
         const asserts = new TestSchema.Asserts(schema)
 
         const decoding = asserts.decoding()
@@ -1638,11 +1638,11 @@ Expected a value between -2147483648 and 2147483647, got 9007199254740992`
         )
       })
 
-      it("isPropertiesLength with symbol keys", async () => {
+      it("isPropertiesLengthBetween with symbol keys", async () => {
         const sym1 = Symbol("test1")
         const sym2 = Symbol("test2")
         const schema = Schema.Record(Schema.Union([Schema.String, Schema.Symbol]), Schema.Number).check(
-          Schema.isPropertiesLength(2)
+          Schema.isPropertiesLengthBetween(2, 2)
         )
         const asserts = new TestSchema.Asserts(schema)
 

packages/effect/test/schema/toArbitrary.test.ts

@@ -471,9 +471,9 @@ describe("Arbitrary generation", () => {
       )
     })
 
-    it("isPropertiesLength(2)", () => {
+    it("isPropertiesLengthBetween(2, 2)", () => {
       verifyGeneration(
-        Schema.Record(Schema.String, Schema.Number).check(Schema.isPropertiesLength(2))
+        Schema.Record(Schema.String, Schema.Number).check(Schema.isPropertiesLengthBetween(2, 2))
       )
     })
 

packages/effect/test/schema/toJsonSchemaDocument.test.ts

@@ -2687,9 +2687,9 @@ describe("toJsonSchemaDocument", () => {
         )
       })
 
-      it("isPropertiesLength", () => {
+      it("isPropertiesLengthBetween", () => {
         assertJsonSchemaDocument(
-          Schema.Record(Schema.String, Schema.Finite).check(Schema.isPropertiesLength(2)),
+          Schema.Record(Schema.String, Schema.Finite).check(Schema.isPropertiesLengthBetween(2, 2)),
           {
             schema: {
               "type": "object",