Callback on function arguments throws error

I’ve started using this package to automatically infer types for Typescript declarations and to ensure object schemas, however I’ve came across some issues when it comes to having callbacks on functions.

When declarating a function like this:

function processAndCallback(num, string, callback) {
    // Process data...
    callback(err, "some string", 0)
}

And using a Zod Schema like:

const schema = z.function()
  .args(
    z.number(),
    z.string(),	
    z.function()
        .args(
            z.instanceof(Error),
            z.string({
                invalid_type_error: "Paramether must be a string value",
            }),
            z.number({
                invalid_type_error: "Paramether must be a numeric value",
            })
        )
        .returns(z.void())
        .implement((err: Error, address: string, family: number) => {
            err;
            address;
            family;

            return;
        })
    )
    .returns(z.void())
    .implement((err, options, callback) => {
        err;
        options;
        callback;

        return;
    })

The following error is thrown:

Argument of type '[ZodNumber, ZodString, (err: Error, address: string, family: number) => void]' is not assignable to parameter of type '[] | [ZodTypeAny, ...ZodTypeAny[]]'.
  Type '[ZodNumber, ZodString, (err: Error, address: string, family: number) => void]' is not assignable to type '[ZodTypeAny, ...ZodTypeAny[]]'.
    Type at positions 1 through 2 in source is not compatible with type at position 1 in target.
      Type 'ZodString | ((err: Error, address: string, family: number) => void)' is not assignable to type 'ZodTypeAny'.
        Type '(err: Error, address: string, family: number) => void' is missing the following properties from type 'ZodType<any, any, any>': _type, _output, _input, _def, and 30 more.

What I pretend is generating names for the arguments of the callback on the callback function for Typescript Declarations. The only way I found that could do it was using z.function().implement(). Is there another way?

[DarkenLM]

@andresgutgon After tinkering around with your solution, I managed to make it work. You have my deepest appreciation.

For anyone who may find this issue with the same problem, here’s the final schema:

const allowedFamilyNumbers = [0, 4, 6];
const family = z
    .number()
    .refine((num: number) => allowedFamilyNumbers.includes(num))
    .default(0)
    .optional();
const options = z.object({
    family,
    hints: z.number().optional(),
    all: z.boolean().optional(),
    verbatim: z.boolean().optional()
});

const errorArg = z.instanceof(Error);
const address = z.string();
const callbackArgs = z.union([
    errorArg.or(z.null()),
    address.nullable(),
    family.nullable(),
    z.unknown()
]);

const callbackFnSchema = z.function().args(callbackArgs).returns(z.void());

// Final schema
const fnTypeWithOptn = z.function(z.tuple([
    z.string(),
    options,
    callbackFnSchema
])).returns(z.void())

const fnTypeNoOptn = z.function(z.tuple([
    z.string(),
    callbackFnSchema
])).returns(z.void())

const schemaType = z.union([
    z.null(),
    fnTypeNoOptn,
    fnTypeWithOptn
])

The above schema accepts as valid:

• null
• a function defined like:

function lookupOne(hostname: string, options: z.infer<typeof options>, callback: z.infer<typeof callbackFnSchema>): void {
    try {
        // Process data
        callback(null, "address", 0);
    } catch (e) {
        callback(e, null, null);
    }
    return;
}

• a function defined like:

function lookupOne(hostname: string, callback: z.infer<typeof callbackFnSchema>): void {
    try {
        // Process data
        callback(null, "address", 0);
    } catch (e) {
        callback(e, null, null);
    }
    return;
}

[andresgutgon]

Another source of reference are the types of Node https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/node/dns.d.ts#L118-L122