The minItems filter now checks for an invalid argument (n < 1) an… (

#2955)

.changeset/unlucky-flowers-suffer.md

@@ -0,0 +1,5 @@
+---
+"@effect/schema": patch
+---
+
+The `minItems` filter now checks for an invalid argument (`n < 1`) and, when valid, refines the type to `NonEmptyReadonlyArray<A>`.

packages/schema/dtslint/Schema.ts

@@ -2547,3 +2547,16 @@ S.asSchema(
 
 // $ExpectType Struct<{ a: PropertySignature<"?:", string, never, ":", string, false, "a">; }>
 S.Struct({ a: S.requiredToOptional(aContext, S.String, { decode: Option.some, encode: Option.getOrElse(() => "") }) })
+
+// ---------------------------------------------
+// minItems
+// ---------------------------------------------
+
+// $ExpectType Schema<readonly [string, ...string[]], readonly string[], never>
+S.asSchema(S.Array(S.String).pipe(S.minItems(1)))
+
+// $ExpectType refine<readonly [string, ...string[]], Schema<readonly string[], readonly string[], never>>
+S.Array(S.String).pipe(S.minItems(1))
+
+// $ExpectType Schema<readonly string[], readonly string[], never>
+S.Array(S.String).pipe(S.minItems(1)).from

packages/schema/src/Schema.ts

@@ -3131,6 +3131,10 @@ export function filter<C extends A, B extends A, A = C>(
   refinement: (a: A, options: ParseOptions, self: AST.Refinement) => a is B,
   annotations?: Annotations.Filter<C & B, C>
 ): <I, R>(self: Schema<C, I, R>) => refine<C & B, Schema<A, I, R>>
+export function filter<A, B extends A>(
+  refinement: (a: A, options: ParseOptions, self: AST.Refinement) => a is B,
+  annotations?: Annotations.Filter<B, A>
+): <I, R>(self: Schema<A, I, R>) => refine<B, Schema<A, I, R>>
 export function filter<S extends Schema.Any>(
   predicate: (
     a: Types.NoInfer<Schema.Type<S>>,
@@ -5440,18 +5444,28 @@ export type MinItemsTypeId = typeof MinItemsTypeId
  */
 export const minItems = <A>(
   n: number,
-  annotations?: Annotations.Filter<ReadonlyArray<A>>
+  annotations?: Annotations.Filter<array_.NonEmptyReadonlyArray<A>, ReadonlyArray<A>>
 ) =>
-<I, R>(self: Schema<ReadonlyArray<A>, I, R>): filter<Schema<ReadonlyArray<A>, I, R>> =>
-  self.pipe(
-    filter((a): a is ReadonlyArray<A> => a.length >= n, {
-      typeId: MinItemsTypeId,
-      description: `an array of at least ${n} items`,
-      jsonSchema: { minItems: n },
-      [AST.StableFilterAnnotationId]: true,
-      ...annotations
-    })
+<I, R>(
+  self: Schema<ReadonlyArray<A>, I, R>
+): refine<array_.NonEmptyReadonlyArray<A>, Schema<ReadonlyArray<A>, I, R>> => {
+  const minItems = Math.floor(n)
+  if (minItems < 1) {
+    throw new Error(`minItems: Expected an integer greater than or equal to 1, actual ${n}`)
+  }
+  return self.pipe(
+    filter(
+      (a): a is array_.NonEmptyReadonlyArray<A> => a.length >= minItems,
+      {
+        typeId: MinItemsTypeId,
+        description: `an array of at least ${minItems} items`,
+        jsonSchema: { minItems },
+        [AST.StableFilterAnnotationId]: true,
+        ...annotations
+      }
+    )
   )
+}
 
 /**
  * @category type id

packages/schema/test/Schema/Array/minItems.test.ts

@@ -1,10 +1,16 @@
 import * as S from "@effect/schema/Schema"
 import * as Util from "@effect/schema/test/TestUtils"
-import { describe, it } from "vitest"
+import { describe, expect, it } from "vitest"
 
 describe("minItems", () => {
-  const schema = S.Array(S.Number).pipe(S.minItems(2))
+  it("should throw for invalid argument", () => {
+    expect(() => S.Array(S.Number).pipe(S.minItems(-1))).toThrowError(
+      new Error("minItems: Expected an integer greater than or equal to 1, actual -1")
+    )
+  })
+
   it("decoding", async () => {
+    const schema = S.Array(S.Number).pipe(S.minItems(2))
     await Util.expectDecodeUnknownFailure(
       schema,
       [1],