Merge pull request #998 from 43081j/actions-everywhere

fabian-hiller · web-flow · commit 40e2bc5032b1 · 2025-01-08T18:42:00.000-05:00
feat: support more actions in JSON schema conversion
diff --git a/library/eslint.config.js b/library/eslint.config.js
@@ -61,7 +61,7 @@ export default tseslint.config(
         },
       ],
 
-      // Regexp
+      // RegExp
       'regexp/no-super-linear-move': 'error', // Prevent DoS regexps
       'regexp/no-control-character': 'error', // Avoid unneeded regexps characters
       'regexp/no-octal': 'error', // Avoid unneeded regexps characters
@@ -91,6 +91,9 @@ export default tseslint.config(
       'jsdoc/require-param-type': 'off',
       'jsdoc/require-returns-type': 'off',
 
+      // RegExp
+      'regexp/use-ignore-case': 'off', // We sometimes don't use the i flag for a better JSON Schema compatibility
+
       // Security
       'security/detect-object-injection': 'off', // Too many false positives
       'security/detect-unsafe-regex': 'off', // Too many false positives, see https://github.com/eslint-community/eslint-plugin-security/issues/28 - we use the redos-detector plugin instead
diff --git a/library/src/actions/octal/octal.test.ts b/library/src/actions/octal/octal.test.ts
@@ -89,15 +89,6 @@ describe('octal', () => {
         '0o1234567',
       ]);
     });
-
-    test('for 0O prefix', () => {
-      expectNoActionIssue(action, [
-        '0O000000000000000',
-        '0O777777777777',
-        '0O01234567',
-        '0O1234567',
-      ]);
-    });
   });
 
   describe('should return dataset with issues', () => {
diff --git a/library/src/regex.ts b/library/src/regex.ts
@@ -42,14 +42,18 @@ export const EMOJI_REGEX: RegExp =
 
 /**
  * [Hexadecimal](https://en.wikipedia.org/wiki/Hexadecimal) regex.
+ *
+ * Hint: We decided against the `i` flag for better JSON Schema compatibility.
  */
-export const HEXADECIMAL_REGEX: RegExp = /^(?:0[hx])?[\da-f]+$/iu;
+export const HEXADECIMAL_REGEX: RegExp = /^(?:0[hx])?[\da-fA-F]+$/u;
 
 /**
  * [Hex color](https://en.wikipedia.org/wiki/Web_colors#Hex_triplet) regex.
+ *
+ * Hint: We decided against the `i` flag for better JSON Schema compatibility.
  */
 export const HEX_COLOR_REGEX: RegExp =
-  /^#(?:[\da-f]{3,4}|[\da-f]{6}|[\da-f]{8})$/iu;
+  /^#(?:[\da-fA-F]{3,4}|[\da-fA-F]{6}|[\da-fA-F]{8})$/u;
 
 /**
  * [IMEI](https://en.wikipedia.org/wiki/International_Mobile_Equipment_Identity) regex.
@@ -135,7 +139,7 @@ export const NANO_ID_REGEX: RegExp = /^[\w-]+$/u;
 /**
  * [Octal](https://en.wikipedia.org/wiki/Octal) regex.
  */
-export const OCTAL_REGEX: RegExp = /^(?:0o)?[0-7]+$/iu;
+export const OCTAL_REGEX: RegExp = /^(?:0o)?[0-7]+$/u;
 
 /**
  * [RFC 5322 email address](https://datatracker.ietf.org/doc/html/rfc5322#section-3.4.1) regex.
@@ -147,8 +151,10 @@ export const RFC_EMAIL_REGEX: RegExp =
 
 /**
  * [ULID](https://github.com/ulid/spec) regex.
+ *
+ * Hint: We decided against the `i` flag for better JSON Schema compatibility.
  */
-export const ULID_REGEX: RegExp = /^[\da-hjkmnp-tv-z]{26}$/iu;
+export const ULID_REGEX: RegExp = /^[\da-hjkmnp-tv-zA-HJKMNP-TV-Z]{26}$/u;
 
 /**
  * [UUID](https://en.wikipedia.org/wiki/Universally_unique_identifier) regex.
diff --git a/packages/to-json-schema/CHANGELOG.md b/packages/to-json-schema/CHANGELOG.md
@@ -6,6 +6,7 @@ All notable changes to the library will be documented in this file.
 
 - Add support for `undefinedable` schema
 - Add support for `base64`, `isoTime`, `isoDateTime`, `nonEmpty` and `url` action (pull request #962)
+- Add support for `bic`, `cuid2`, `empty`, `decimal`, `digits`, `emoji`, `hex_color`, `hexadecimal`, `nanoid`, `octal` and `ulid` action (pull request #998)
 - Change Valibot peer dependency to v1.0.0
 - Change extraction of default value from `nullable`, `nullish` and `optional` schema
 - Change `force` to `errorMode` in config for better control (issue #889)
diff --git a/packages/to-json-schema/src/convertAction.test.ts b/packages/to-json-schema/src/convertAction.test.ts
@@ -17,6 +17,54 @@ describe('convertAction', () => {
     });
   });
 
+  test('should convert bic action', () => {
+    expect(convertAction({}, v.bic<string>(), undefined)).toStrictEqual({
+      pattern: v.BIC_REGEX.source,
+    });
+    expect(
+      convertAction({ type: 'string' }, v.bic<string>(), undefined)
+    ).toStrictEqual({
+      type: 'string',
+      pattern: v.BIC_REGEX.source,
+    });
+  });
+
+  test('should convert cuid2 action', () => {
+    expect(convertAction({}, v.cuid2<string>(), undefined)).toStrictEqual({
+      pattern: v.CUID2_REGEX.source,
+    });
+    expect(
+      convertAction({ type: 'string' }, v.cuid2<string>(), undefined)
+    ).toStrictEqual({
+      type: 'string',
+      pattern: v.CUID2_REGEX.source,
+    });
+  });
+
+  test('should convert decimal action', () => {
+    expect(convertAction({}, v.decimal<string>(), undefined)).toStrictEqual({
+      pattern: v.DECIMAL_REGEX.source,
+    });
+    expect(
+      convertAction({ type: 'string' }, v.decimal<string>(), undefined)
+    ).toStrictEqual({
+      type: 'string',
+      pattern: v.DECIMAL_REGEX.source,
+    });
+  });
+
+  test('should convert digits action', () => {
+    expect(convertAction({}, v.digits<string>(), undefined)).toStrictEqual({
+      pattern: v.DIGITS_REGEX.source,
+    });
+    expect(
+      convertAction({ type: 'string' }, v.digits<string>(), undefined)
+    ).toStrictEqual({
+      type: 'string',
+      pattern: v.DIGITS_REGEX.source,
+    });
+  });
+
   test('should convert description action', () => {
     expect(convertAction({}, v.description('test'), undefined)).toStrictEqual({
       description: 'test',
@@ -35,6 +83,95 @@ describe('convertAction', () => {
     });
   });
 
+  test('should convert emoji action', () => {
+    expect(convertAction({}, v.emoji<string>(), undefined)).toStrictEqual({
+      pattern: v.EMOJI_REGEX.source,
+    });
+    expect(
+      convertAction({ type: 'string' }, v.emoji<string>(), undefined)
+    ).toStrictEqual({
+      type: 'string',
+      pattern: v.EMOJI_REGEX.source,
+    });
+  });
+
+  test('should convert empty action for strings', () => {
+    expect(
+      convertAction({ type: 'string' }, v.empty(), undefined)
+    ).toStrictEqual({
+      type: 'string',
+      maxLength: 0,
+    });
+  });
+
+  test('should convert empty action for arrays', () => {
+    expect(
+      convertAction({ type: 'array' }, v.empty(), undefined)
+    ).toStrictEqual({
+      type: 'array',
+      maxItems: 0,
+    });
+  });
+
+  test('should throw error for empty action with invalid type', () => {
+    const action = v.empty();
+    const error1 = 'The "empty" action is not supported on type "undefined".';
+    expect(() => convertAction({}, action, undefined)).toThrowError(error1);
+    expect(() =>
+      convertAction({}, action, { errorMode: 'throw' })
+    ).toThrowError(error1);
+    const error2 = 'The "empty" action is not supported on type "object".';
+    expect(() =>
+      convertAction({ type: 'object' }, action, undefined)
+    ).toThrowError(error2);
+    expect(() =>
+      convertAction({ type: 'object' }, action, { errorMode: 'throw' })
+    ).toThrowError(error2);
+  });
+
+  test('should warn error for empty action with invalid type', () => {
+    expect(convertAction({}, v.empty(), { errorMode: 'warn' })).toStrictEqual({
+      maxLength: 0,
+    });
+    expect(console.warn).toHaveBeenLastCalledWith(
+      'The "empty" action is not supported on type "undefined".'
+    );
+    expect(
+      convertAction({ type: 'object' }, v.empty(), {
+        errorMode: 'warn',
+      })
+    ).toStrictEqual({ type: 'object', maxLength: 0 });
+    expect(console.warn).toHaveBeenLastCalledWith(
+      'The "empty" action is not supported on type "object".'
+    );
+  });
+
+  test('should convert hexadecimal action', () => {
+    expect(convertAction({}, v.hexadecimal<string>(), undefined)).toStrictEqual(
+      {
+        pattern: v.HEXADECIMAL_REGEX.source,
+      }
+    );
+    expect(
+      convertAction({ type: 'string' }, v.hexadecimal<string>(), undefined)
+    ).toStrictEqual({
+      type: 'string',
+      pattern: v.HEXADECIMAL_REGEX.source,
+    });
+  });
+
+  test('should convert hex color action', () => {
+    expect(convertAction({}, v.hexColor<string>(), undefined)).toStrictEqual({
+      pattern: v.HEX_COLOR_REGEX.source,
+    });
+    expect(
+      convertAction({ type: 'string' }, v.hexColor<string>(), undefined)
+    ).toStrictEqual({
+      type: 'string',
+      pattern: v.HEX_COLOR_REGEX.source,
+    });
+  });
+
   test('should convert integer action', () => {
     expect(convertAction({}, v.integer<number>(), undefined)).toStrictEqual({
       type: 'integer',
@@ -418,6 +555,18 @@ describe('convertAction', () => {
     });
   });
 
+  test('should convert Nano ID action', () => {
+    expect(convertAction({}, v.nanoid<string>(), undefined)).toStrictEqual({
+      pattern: v.NANO_ID_REGEX.source,
+    });
+    expect(
+      convertAction({ type: 'string' }, v.nanoid<string>(), undefined)
+    ).toStrictEqual({
+      type: 'string',
+      pattern: v.NANO_ID_REGEX.source,
+    });
+  });
+
   test('should convert non empty action for strings', () => {
     expect(
       convertAction({ type: 'string' }, v.nonEmpty(), undefined)
@@ -472,6 +621,18 @@ describe('convertAction', () => {
     );
   });
 
+  test('should convert octal action', () => {
+    expect(convertAction({}, v.octal<string>(), undefined)).toStrictEqual({
+      pattern: v.OCTAL_REGEX.source,
+    });
+    expect(
+      convertAction({ type: 'string' }, v.octal<string>(), undefined)
+    ).toStrictEqual({
+      type: 'string',
+      pattern: v.OCTAL_REGEX.source,
+    });
+  });
+
   test('should convert supported regex action', () => {
     expect(
       convertAction({ type: 'string' }, v.regex<string>(/[a-zA-Z]/), undefined)
@@ -510,6 +671,18 @@ describe('convertAction', () => {
     });
   });
 
+  test('should convert ULID action', () => {
+    expect(convertAction({}, v.ulid<string>(), undefined)).toStrictEqual({
+      pattern: v.ULID_REGEX.source,
+    });
+    expect(
+      convertAction({ type: 'string' }, v.ulid<string>(), undefined)
+    ).toStrictEqual({
+      type: 'string',
+      pattern: v.ULID_REGEX.source,
+    });
+  });
+
   test('should convert url action', () => {
     expect(convertAction({}, v.url<string>(), undefined)).toStrictEqual({
       format: 'uri',
diff --git a/packages/to-json-schema/src/convertAction.ts b/packages/to-json-schema/src/convertAction.ts
@@ -3,15 +3,30 @@ import type * as v from 'valibot';
 import type { ConversionConfig } from './type.ts';
 import { handleError } from './utils/index.ts';
 
-// TODO: Add support for more actions (for example all regex-based actions)
-
 /**
  * Action type.
  */
 type Action =
   | v.Base64Action<string, v.ErrorMessage<v.Base64Issue<string>> | undefined>
+  | v.BicAction<string, v.ErrorMessage<v.BicIssue<string>> | undefined>
+  | v.Cuid2Action<string, v.ErrorMessage<v.Cuid2Issue<string>> | undefined>
+  | v.DecimalAction<string, v.ErrorMessage<v.DecimalIssue<string>> | undefined>
   | v.DescriptionAction<unknown, string>
+  | v.DigitsAction<string, v.ErrorMessage<v.DigitsIssue<string>> | undefined>
   | v.EmailAction<string, v.ErrorMessage<v.EmailIssue<string>> | undefined>
+  | v.EmojiAction<string, v.ErrorMessage<v.EmojiIssue<string>> | undefined>
+  | v.EmptyAction<
+      v.LengthInput,
+      v.ErrorMessage<v.EmptyIssue<v.LengthInput>> | undefined
+    >
+  | v.HexadecimalAction<
+      string,
+      v.ErrorMessage<v.HexadecimalIssue<string>> | undefined
+    >
+  | v.HexColorAction<
+      string,
+      v.ErrorMessage<v.HexColorIssue<string>> | undefined
+    >
   | v.IntegerAction<number, v.ErrorMessage<v.IntegerIssue<number>> | undefined>
   | v.Ipv4Action<string, v.ErrorMessage<v.Ipv4Issue<string>> | undefined>
   | v.Ipv6Action<string, v.ErrorMessage<v.Ipv6Issue<string>> | undefined>
@@ -30,10 +45,6 @@ type Action =
       number,
       v.ErrorMessage<v.LengthIssue<v.LengthInput, number>> | undefined
     >
-  | v.NonEmptyAction<
-      v.LengthInput,
-      v.ErrorMessage<v.NonEmptyIssue<v.LengthInput>> | undefined
-    >
   | v.MaxLengthAction<
       v.LengthInput,
       number,
@@ -59,8 +70,15 @@ type Action =
       number,
       v.ErrorMessage<v.MultipleOfIssue<number, number>> | undefined
     >
+  | v.NanoIDAction<string, v.ErrorMessage<v.NanoIDIssue<string>> | undefined>
+  | v.NonEmptyAction<
+      v.LengthInput,
+      v.ErrorMessage<v.NonEmptyIssue<v.LengthInput>> | undefined
+    >
+  | v.OctalAction<string, v.ErrorMessage<v.OctalIssue<string>> | undefined>
   | v.RegexAction<string, v.ErrorMessage<v.RegexIssue<string>> | undefined>
   | v.TitleAction<unknown, string>
+  | v.UlidAction<string, v.ErrorMessage<v.UlidIssue<string>> | undefined>
   | v.UrlAction<string, v.ErrorMessage<v.UrlIssue<string>> | undefined>
   | v.UuidAction<string, v.ErrorMessage<v.UuidIssue<string>> | undefined>
   | v.ValueAction<
@@ -89,6 +107,20 @@ export function convertAction(
       break;
     }
 
+    case 'bic':
+    case 'cuid2':
+    case 'decimal':
+    case 'digits':
+    case 'emoji':
+    case 'hexadecimal':
+    case 'hex_color':
+    case 'nanoid':
+    case 'octal':
+    case 'ulid': {
+      jsonSchema.pattern = valibotAction.requirement.source;
+      break;
+    }
+
     case 'description': {
       jsonSchema.description = valibotAction.description;
       break;
@@ -99,6 +131,21 @@ export function convertAction(
       break;
     }
 
+    case 'empty': {
+      if (jsonSchema.type === 'array') {
+        jsonSchema.maxItems = 0;
+      } else {
+        if (jsonSchema.type !== 'string') {
+          handleError(
+            `The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`,
+            config
+          );
+        }
+        jsonSchema.maxLength = 0;
+      }
+      break;
+    }
+
     case 'integer': {
       jsonSchema.type = 'integer';
       break;
