add checkItemsAsync action

library/CHANGELOG.md

@@ -4,6 +4,7 @@ All notable changes to the library will be documented in this file.
 
 ## v1.0.0 (Month DD, YYYY)
 
+- Add `checkItemsAsync` action (pull request #856)
 - Change types and implementation to support Standard Schema
 
 ## v0.42.1 (September 20, 2024)

library/src/actions/checkItems/checkItems.test-d.ts

@@ -1,41 +1,29 @@
 import { describe, expectTypeOf, test } from 'vitest';
 import type { InferInput, InferIssue, InferOutput } from '../../types/index.ts';
-import {
-  checkItems,
-  type CheckItemsAction,
-  type CheckItemsIssue,
-} from './checkItems.ts';
+import { checkItems, type CheckItemsAction } from './checkItems.ts';
+import type { CheckItemsIssue } from './types.ts';
 
 describe('checkItems', () => {
   describe('should return action object', () => {
+    const requirement = (item: string) => Boolean(item);
+
     test('with undefined message', () => {
       type Action = CheckItemsAction<string[], undefined>;
+      expectTypeOf(checkItems<string[]>(requirement)).toEqualTypeOf<Action>();
       expectTypeOf(
-        checkItems<string[]>((item: string) => Boolean(item))
-      ).toEqualTypeOf<Action>();
-      expectTypeOf(
-        checkItems<string[], undefined>(
-          (item: string) => Boolean(item),
-          undefined
-        )
+        checkItems<string[], undefined>(requirement, undefined)
       ).toEqualTypeOf<Action>();
     });
 
     test('with string message', () => {
       expectTypeOf(
-        checkItems<string[], 'message'>(
-          (item: string) => Boolean(item),
-          'message'
-        )
+        checkItems<string[], 'message'>(requirement, 'message')
       ).toEqualTypeOf<CheckItemsAction<string[], 'message'>>();
     });
 
     test('with function message', () => {
       expectTypeOf(
-        checkItems<string[], () => string>(
-          (item: string) => Boolean(item),
-          () => 'message'
-        )
+        checkItems<string[], () => string>(requirement, () => 'message')
       ).toEqualTypeOf<CheckItemsAction<string[], () => string>>();
     });
   });

library/src/actions/checkItems/checkItems.test.ts

@@ -2,11 +2,8 @@ import { describe, expect, test } from 'vitest';
 import type { StringIssue } from '../../schemas/index.ts';
 import type { PartialDataset } from '../../types/dataset.ts';
 import { expectNoActionIssue } from '../../vitest/index.ts';
-import {
-  checkItems,
-  type CheckItemsAction,
-  type CheckItemsIssue,
-} from './checkItems.ts';
+import { checkItems, type CheckItemsAction } from './checkItems.ts';
+import type { CheckItemsIssue } from './types.ts';
 
 describe('checkItems', () => {
   describe('should return action object', () => {

library/src/actions/checkItems/checkItems.ts

@@ -1,35 +1,7 @@
-import type {
-  BaseIssue,
-  BaseValidation,
-  ErrorMessage,
-} from '../../types/index.ts';
+import type { BaseValidation, ErrorMessage } from '../../types/index.ts';
 import { _addIssue } from '../../utils/index.ts';
 import type { ArrayInput, ArrayRequirement } from '../types.ts';
-
-// TODO: Also add `checkItemsAsync` action
-
-/**
- * Check items issue type.
- */
-export interface CheckItemsIssue<TInput extends ArrayInput>
-  extends BaseIssue<TInput[number]> {
-  /**
-   * The issue kind.
-   */
-  readonly kind: 'validation';
-  /**
-   * The issue type.
-   */
-  readonly type: 'check_items';
-  /**
-   * The expected input.
-   */
-  readonly expected: null;
-  /**
-   * The validation function.
-   */
-  readonly requirement: ArrayRequirement<TInput>;
-}
+import type { CheckItemsIssue } from './types.ts';
 
 /**
  * Check items action type.

library/src/actions/checkItems/checkItemsAsync.test-d.ts

@@ -0,0 +1,54 @@
+import { describe, expectTypeOf, test } from 'vitest';
+import type { InferInput, InferIssue, InferOutput } from '../../types/index.ts';
+import {
+  type CheckItemsActionAsync,
+  checkItemsAsync,
+} from './checkItemsAsync.ts';
+import type { CheckItemsIssue } from './types.ts';
+
+describe('checkItemsAsync', () => {
+  describe('should return action object', () => {
+    const requirement = async (item: string) => Boolean(item);
+
+    test('with undefined message', () => {
+      type Action = CheckItemsActionAsync<string[], undefined>;
+      expectTypeOf(
+        checkItemsAsync<string[]>(requirement)
+      ).toEqualTypeOf<Action>();
+      expectTypeOf(
+        checkItemsAsync<string[], undefined>(requirement, undefined)
+      ).toEqualTypeOf<Action>();
+    });
+
+    test('with string message', () => {
+      expectTypeOf(
+        checkItemsAsync<string[], 'message'>(requirement, 'message')
+      ).toEqualTypeOf<CheckItemsActionAsync<string[], 'message'>>();
+    });
+
+    test('with function message', () => {
+      expectTypeOf(
+        checkItemsAsync<string[], () => string>(requirement, () => 'message')
+      ).toEqualTypeOf<CheckItemsActionAsync<string[], () => string>>();
+    });
+  });
+
+  describe('should infer correct types', () => {
+    type Input = ['foo', 123, true];
+    type Action = CheckItemsActionAsync<Input, undefined>;
+
+    test('of input', () => {
+      expectTypeOf<InferInput<Action>>().toEqualTypeOf<Input>();
+    });
+
+    test('of output', () => {
+      expectTypeOf<InferOutput<Action>>().toEqualTypeOf<Input>();
+    });
+
+    test('of issue', () => {
+      expectTypeOf<InferIssue<Action>>().toEqualTypeOf<
+        CheckItemsIssue<Input>
+      >();
+    });
+  });
+});

library/src/actions/checkItems/checkItemsAsync.test.ts

@@ -0,0 +1,147 @@
+import { describe, expect, test } from 'vitest';
+import type { StringIssue } from '../../schemas/index.ts';
+import type { PartialDataset } from '../../types/dataset.ts';
+import { expectNoActionIssueAsync } from '../../vitest/index.ts';
+import {
+  type CheckItemsActionAsync,
+  checkItemsAsync,
+} from './checkItemsAsync.ts';
+import type { CheckItemsIssue } from './types.ts';
+
+describe('checkItemsAsync', () => {
+  describe('should return action object', () => {
+    const requirement = async (item: string) => item.startsWith('DE');
+    const baseAction: Omit<
+      CheckItemsActionAsync<string[], never>,
+      'message'
+    > = {
+      kind: 'validation',
+      type: 'check_items',
+      reference: checkItemsAsync,
+      expects: null,
+      requirement,
+      async: true,
+      '~validate': expect.any(Function),
+    };
+
+    test('with undefined message', () => {
+      const action: CheckItemsActionAsync<string[], undefined> = {
+        ...baseAction,
+        message: undefined,
+      };
+      expect(checkItemsAsync<string[]>(requirement)).toStrictEqual(action);
+      expect(
+        checkItemsAsync<string[], undefined>(requirement, undefined)
+      ).toStrictEqual(action);
+    });
+
+    test('with string message', () => {
+      const message = 'message';
+      expect(
+        checkItemsAsync<string[], 'message'>(requirement, message)
+      ).toStrictEqual({
+        ...baseAction,
+        message,
+      } satisfies CheckItemsActionAsync<string[], 'message'>);
+    });
+
+    test('with function message', () => {
+      const message = () => 'message';
+      expect(
+        checkItemsAsync<string[], typeof message>(requirement, message)
+      ).toStrictEqual({
+        ...baseAction,
+        message,
+      } satisfies CheckItemsActionAsync<string[], typeof message>);
+    });
+  });
+
+  describe('should return dataset without issues', () => {
+    const action = checkItemsAsync<number[]>(async (item: number) => item > 9);
+
+    test('for untyped inputs', async () => {
+      const issues: [StringIssue] = [
+        {
+          kind: 'schema',
+          type: 'string',
+          input: null,
+          expected: 'string',
+          received: 'null',
+          message: 'message',
+        },
+      ];
+      expect(
+        await action['~validate']({ typed: false, value: null, issues }, {})
+      ).toStrictEqual({
+        typed: false,
+        value: null,
+        issues,
+      });
+    });
+
+    test('for empty array', async () => {
+      await expectNoActionIssueAsync(action, [[]]);
+    });
+
+    test('for valid content', async () => {
+      await expectNoActionIssueAsync(action, [[10, 11, 12, 13, 99]]);
+    });
+  });
+
+  describe('should return dataset with issues', () => {
+    const requirement = async (item: number) => item > 9;
+    const action = checkItemsAsync<number[], 'message'>(requirement, 'message');
+
+    const baseIssue: Omit<CheckItemsIssue<number[]>, 'input' | 'received'> = {
+      kind: 'validation',
+      type: 'check_items',
+      expected: null,
+      message: 'message',
+      requirement,
+      issues: undefined,
+      lang: undefined,
+      abortEarly: undefined,
+      abortPipeEarly: undefined,
+    };
+
+    test('for invalid content', async () => {
+      const input = [-12, 345, 6, 10];
+      expect(
+        await action['~validate']({ typed: true, value: input }, {})
+      ).toStrictEqual({
+        typed: true,
+        value: input,
+        issues: [
+          {
+            ...baseIssue,
+            input: input[0],
+            received: `${input[0]}`,
+            path: [
+              {
+                type: 'array',
+                origin: 'value',
+                input,
+                key: 0,
+                value: input[0],
+              },
+            ],
+          },
+          {
+            ...baseIssue,
+            input: input[2],
+            received: `${input[2]}`,
+            path: [
+              {
+                type: 'array',
+                origin: 'value',
+                input,
+                key: 2,
+                value: input[2],
+              },
+            ],
+          },
+        ],
+      } satisfies PartialDataset<number[], CheckItemsIssue<number[]>>);
+    });
+  });
+});