Can't use `bigint` (and more) with `experimental_ArkTypeToJsonSchemaConverter`

[boredland]

Environment

@orpc/*@1.8.0
node@22

Reproduction

https://github.com/boredland/orpc-arktype-openapi-repro

Describe the bug

I tried to stick mostly to the docs around openapi, sadly most of my arktype validators didn't work, as soon as I provided "slightly" more complicated validation logic in my schema (like a bigint, transformations, narrows etc. - included some commented-out examples in my repro). Isn't this supposed to work? I know it is marked experimental, so my expectations were not very high, but also I didn't expect it to crash out with simple examples like that and fear I might be doing something wrong.

Additional context

No response

Logs

for example:


file:/.../orpc-arktype-swagger-repro/node_modules/@ark/schema/out/shared/toJsonSchema.js:35
        throw new ToJsonSchema.Error(...args);
              ^

ToJsonSchemaError: {
    code: "predicate",
    base: {
        type: "string"
    },
    predicate: Function(isParsableDate)
}

[dosubot]

The inability to use advanced arktype validators like bigint, custom predicates, narrows, and transformations with experimental_ArkTypeToJsonSchemaConverter is a known limitation. The converter simply delegates to ArkType's own toJsonSchema method, which does not support these features and will throw errors (like the ToJsonSchemaError you saw) when it encounters them. This is expected behavior for now, as the converter is marked experimental and only reliably supports basic types (e.g., string, object, Date). Unsupported types either error or, in some cases, fall back to a null schema if a fallback is configured. There is currently no mechanism in orpc to provide custom fallbacks for these advanced features, and no active workarounds are documented in the project or recent pull requests. For now, only use simple arktype validators with the converter, or manually define your OpenAPI schemas for more complex cases.
Source: converter implementation and docs
Source: OpenAPI docs warning

To reply, just mention @dosu.

---

^{How did I do? Good | Irrelevant | Incorrect | Verbose | Hallucination | Report 🐛 | Other}    

[boredland]

I guess the AI-answer is wrong, but pointed me into the right direction, as ArkTypeToJsonSchemaConverter does in fact accept arktype fallback config options. Will test!

[dosubot]

You're right—ArkTypeToJsonSchemaConverter does support arktype fallback config options. The converter merges your custom fallback handlers with its built-in defaults, so you can define how unsupported types (like bigint, custom predicates, etc.) are represented in the generated JSON Schema. For example, you can provide a fallback that returns a special schema for anything ArkType can't serialize:

const converter = new ArkTypeToJsonSchemaConverter({
  fallback: {
    default: () => ({
      type: 'null',
      'x-type': 'null',
    }),
  },
});

This way, instead of crashing, the converter will emit your fallback schema for unsupported types. Note that this doesn't enable full JSON Schema support for advanced arktype features—it just lets you control how they're surfaced in the output. For more details, see the implementation and test examples in the codebase
converter implementation
test example.

To reply, just mention @dosu.

---

^{How did I do? Good | Irrelevant | Incorrect | Verbose | Hallucination | Report 🐛 | Other}    

[boredland]

Ya, this is how my converter looks like for now:

    new ArkTypeToJsonSchemaConverter({
      fallback: {
        default: ctx => ctx.base,
        date: ctx => ({
          ...ctx.base,
          type: "string",
          format: "date-time",
          description: ctx.after ? `after ${ctx.after}` : "anytime",
          "x-native-type": "date",
        }),
        domain: ctx => {
          if (ctx.domain === "bigint") {
            return {
              ...ctx.base,
              type: "string",
              description: "bigint as string",
              example: "12345678901234567890",
              "x-native-type": "bigint",
            }
          }
          return ctx.base
        },
        morph: (ctx) => {
          return ctx.base
        }
      }
    }),