nullables.test.ts.snap

// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html

exports[`const values 1`] = `
"export type StringConst = "hello";
export type NumberConst = 42;
export type BooleanConst = true;
export type NullConst = null;
"
`;

exports[`const values 2`] = `
"import * as v from "valibot";

export const stringConstSchema = v.literal("hello");
export const numberConstSchema = v.literal(42);
export const booleanConstSchema = v.literal(true);
export const nullConstSchema = v.null();
"
`;

exports[`header parameters 1`] = `
"export type UploadStatus = "pending" | "complete";
export type UploadDataCommandHeader = {
        "content-type": "application/json" | "text/csv" | "application/xml";
        "content-length": number;
        "x-idempotency-key"?: string | undefined;
    };
export type UploadDataCommandParams = {
        uploadId: string;
    };
export type UploadDataCommandInput = UploadDataCommandParams;
"
`;

exports[`header parameters 2`] = `
"import { Command } from "@block65/rest-client";
import type { UploadDataCommandHeader, UploadDataCommandInput, UploadStatus } from "./types.js";

/**
 * Tagged template literal that applies encodeURIComponent to all interpolated 
 * values, protecting path integrity from characters like \`/\` and \`#\`.
 * @example encodePath\`/users/\${userId}\` // "/users/foo%2Fbar"
 */
function encodePath(strings: TemplateStringsArray, ...values: string[]): string {
    return String.raw({ raw: strings }, ...values.map(encodeURIComponent));
}

/**
 * UploadDataCommand
 *
 */
export class UploadDataCommand extends Command<UploadDataCommandInput, UploadStatus, never, UploadDataCommandHeader> {
    public override method = "post" as const;

    constructor(input: UploadDataCommandInput, headers: UploadDataCommandHeader) {
        const {uploadId } = input;
        super(encodePath\`/uploads/\${uploadId}\`, undefined, undefined, headers);
    }
}
"
`;

exports[`header parameters 3`] = `
"import * as v from "valibot";

export const uploadStatusSchema = v.picklist(["pending", "complete"]);
export const uploadDataCommandParamsSchema = v.strictObject({
        "uploadId": v.string()
    });
export const uploadDataCommandHeaderSchema = v.object({
        "content-type": v.picklist(["application/json", "text/csv", "application/xml"]),
        "content-length": v.pipe(v.string(), v.digits(), v.transform((n) => Number.parseInt(n, 10)), v.number(), v.integer()),
        "x-idempotency-key": v.exactOptional(v.pipe(v.string(), v.uuid()))
    });
"
`;

exports[`header parameters 4`] = `
"import { validator } from "hono/validator";
import * as v from "valibot";
import { PublicValibotHonoError } from "@block65/rest-client";
import { uploadDataCommandParamsSchema } from "./valibot.js";

function toPublicValibotHonoError(err: unknown): never {

          if (err instanceof v.ValiError) {
            throw PublicValibotHonoError.from(err);
          }
          throw err;
        
}

export const uploadData = [
        validator("param", (value) => {
            return v.parseAsync(uploadDataCommandParamsSchema, value).catch(toPublicValibotHonoError);
        }),
    ] as const;
"
`;

exports[`nullables 1`] = `
"export type MySchemaLolOrNullable = "lol" | "kek" | null;
"
`;

exports[`oneOf with type null generates v.null() 1`] = `
"import * as v from "valibot";

export const nullableImageSchema = v.union([v.string(), v.null()]);
"
`;

exports[`query and header integer params coerce strings to numbers 1`] = `
"export type Dummy = string;
export type ExpireTime = number;
export type ListFilesCommandQuery = {
        exp: \`\${number}\`;
        limit?: \`\${number}\` | undefined;
    };
export type ListFilesCommandHeader = {
        "x-rate-limit": number;
    };
export type ListFilesCommandInput = ListFilesCommandQuery;
"
`;

exports[`query and header integer params coerce strings to numbers 2`] = `
"import * as v from "valibot";

export const dummySchema = v.string();
export const expireTimeSchema = v.pipe(v.number(), v.integer(), v.minValue(0));
export const listFilesCommandQuerySchema = v.strictObject({
        "exp": v.pipe(v.string(), v.digits(), v.transform((n) => Number.parseInt(n, 10)), v.number(), v.integer(), v.minValue(0)),
        "limit": v.exactOptional(v.pipe(v.string(), v.digits(), v.transform((n) => Number.parseInt(n, 10)), v.number(), v.integer(), v.minValue(1), v.maxValue(100)))
    });
export const listFilesCommandHeaderSchema = v.object({
        "x-rate-limit": v.pipe(v.string(), v.digits(), v.transform((n) => Number.parseInt(n, 10)), v.number(), v.integer(), v.minValue(0))
    });
"
`;

exports[`top-level type array with null 1`] = `
"export type NullableString = string | null;
export type NullableStringEnum = "active" | "inactive" | null;
export type NullableInteger = number | null;
export type MultiType = string | number;
"
`;

exports[`top-level type array with null 2`] = `
"import * as v from "valibot";

export const nullableStringSchema = v.nullable(v.string());
export const nullableStringEnumSchema = v.nullable(v.picklist(["active", "inactive"]));
export const nullableIntegerSchema = v.nullable(v.pipe(v.number(), v.integer()));
export const multiTypeSchema = v.union([v.string(), v.number()]);
"
`;

exports[`top-level type array with null 3`] = `
"export const nullableStringEnum = ["active", "inactive"] as const;
"
`;