"wrangler": minor

Add `--check` flag to `wrangler types` command

The new `--check` flag allows you to verify that your generated types file is up-to-date without regenerating it. This is useful for CI/CD pipelines, pre-commit hooks, or any scenario where you want to ensure types have been committed after configuration changes.

When types are up-to-date, the command exits with code 0:

$ wrangler types --check

✨ Types at worker-configuration.d.ts are up to date.

When types are out-of-date, the command exits with code 1:

$ wrangler types --check

✘ [ERROR] Types at worker-configuration.d.ts are out of date. Run `wrangler types` to regenerate.

You can also use it with a custom output path:

$ wrangler types ./custom-types.d.ts --check

import { beforeEach, describe, expect, it } from "vitest";

describe("--check", () => {

let helper: WranglerE2ETestHelper;

beforeEach(async () => {

helper = new WranglerE2ETestHelper();

await helper.seed(seed);

});

it("should not error when types are up to date", async () => {

await helper.run(`wrangler types`);

const output = await helper.run(`wrangler types --check`);

expect(output.stderr).toBeFalsy();

expect(output.stdout).toContain("up to date");

expect(output.status).toBe(0);

});

it("should error when env types are out of date", async () => {

await helper.run(`wrangler types`);

await helper.seed({

...seed,

"wrangler.jsonc": JSON.stringify({

name: "test-worker",

main: "src/index.ts",

compatibility_date: "2026-01-01",

compatibility_flags: ["nodejs_compat", "no_global_navigator"],

vars: {

NEW_VAR: "new-value",

},

}),

});

const output = await helper.run(`wrangler types --check`);

expect(output.stderr).toContain("out of date");

expect(output.status).toBe(1);

});

it("should error when runtime types are out of date", async () => {

await helper.run(`wrangler types`);

await helper.seed({

...seed,

"wrangler.jsonc": JSON.stringify({

name: "test-worker",

main: "src/index.ts",

compatibility_date: "2026-01-01",

compatibility_flags: ["nodejs_compat"],

vars: {

MY_VAR: "my-var-value",

},

}),

});

const output = await helper.run(`wrangler types --check`);

expect(output.stderr).toContain("out of date");

expect(output.status).toBe(1);

});

it("should work with custom output path", async () => {

await helper.run(`wrangler types ./custom.d.ts`);

const output = await helper.run(`wrangler types ./custom.d.ts --check`);

expect(output.stderr).toBeFalsy();

expect(output.stdout).toContain("./custom.d.ts");

expect(output.stdout).toContain("up to date");

expect(output.status).toBe(0);

});

it("should not error on `--check` if types generated with `--include-env=false`", async () => {

await helper.run(`wrangler types --include-env=false`);

const output = await helper.run(`wrangler types --check`);

expect(output.stderr).toBeFalsy();

expect(output.stdout).toContain("up to date");

expect(output.status).toBe(0);

});

it("should not error on `--check` if types generated with `--include-runtime=false`", async () => {

await helper.run(`wrangler types --include-runtime=false`);

const output = await helper.run(`wrangler types --check`);

expect(output.stderr).toBeFalsy();

expect(output.stdout).toContain("up to date");

expect(output.status).toBe(0);

});

it("should error if types file does not exist", async () => {

const output = await helper.run(`wrangler types --check`);

expect(output.stderr).toContain("not found");

expect(output.status).toBe(1);

});

it("should error if types file was not generated by wrangler", async () => {

await writeFile(

path.join(helper.tmpPath, "worker-configuration.d.ts"),

"// Some other content\ninterface Foo {}"

);

const output = await helper.run(`wrangler types --check`);

expect(output.stderr).toContain("non-Wrangler");

expect(output.status).toBe(1);

});

});

import { ParseError, UserError } from "@cloudflare/workers-utils";

import yargs from "yargs";

import { getEntry } from "../deployment-bundle/entry";

export const ENV_HEADER_COMMENT_PREFIX = "// Generated by Wrangler by running";

export const RUNTIME_HEADER_COMMENT_PREFIX =

"// Runtime types generated with workerd@";

export const getRuntimeHeader = (

workerdVersion: string,

compatibilityDate: string,

compatibilityFlags: Array<string> = []

): string => {

return `${RUNTIME_HEADER_COMMENT_PREFIX}${workerdVersion} ${compatibilityDate} ${compatibilityFlags.sort().join(",")}`;

const unsafeParseBooleanString = (value: unknown): boolean => {

if (typeof value !== "string") {

throw new ParseError({

text: `Invalid value: ${value}`,

kind: "error",

});

}

if (value.toLowerCase() === "true") {

return true;

}

if (value.toLowerCase() === "false") {

return false;

}

throw new ParseError({

text: `Invalid value: ${value}`,

kind: "error",

});

export const checkTypesUpToDate = async (

primaryConfig: Config,

typesPath: string = DEFAULT_WORKERS_TYPES_FILE_PATH

): Promise<boolean> => {

let typesFileLines = new Array<string>();

try {

typesFileLines = readFileSync(typesPath, "utf-8").split("\n");

} catch (e) {

if ((e as NodeJS.ErrnoException).code === "ENOENT") {

throw new UserError(`Types file not found at ${typesPath}.`);

}

throw e;

}

const existingEnvHeader = typesFileLines.find((line) =>

line.startsWith(ENV_HEADER_COMMENT_PREFIX)

);

const existingRuntimeHeader = typesFileLines.find((line) =>

line.startsWith(RUNTIME_HEADER_COMMENT_PREFIX)

);

if (!existingEnvHeader && !existingRuntimeHeader) {

throw new UserError(`No generated types found in ${typesPath}.`);

}

const { command: wranglerCommand = "", hash: maybeExistingHash } =

existingEnvHeader?.match(

/\/\/ Generated by Wrangler by running `(?<command>.*)` \(hash: (?<hash>[a-zA-Z0-9]+)\)/

)?.groups ?? {};

// Note: `yargs` doesn't automatically handle aliases, so we check both forms

const rawArgs = yargs(wranglerCommand).parseSync();

// Determine what was included based on what headers exist

// If no env header exists, env types were not included (--include-env=false)

// If no runtime header exists, runtime types were not included (--include-runtime=false)

const args = {

includeEnv: existingEnvHeader

? unsafeParseBooleanString(rawArgs.includeEnv ?? "true")

: false,

includeRuntime: existingRuntimeHeader

? unsafeParseBooleanString(rawArgs.includeRuntime ?? "true")

: false,

envInterface: (rawArgs.envInterface ?? "Env") as string,

strictVars: unsafeParseBooleanString(rawArgs.strictVars ?? "true"),

} satisfies Record<string, string | number | boolean>;

const configContainsEntrypoint =

primaryConfig.main !== undefined || !!primaryConfig.site?.["entry-point"];

const entrypoint = configContainsEntrypoint

? await getEntry({}, primaryConfig, "types").catch(() => undefined)

: undefined;

let envOutOfDate = false;

let runtimeOutOfDate = false;

// Check if env types are out of date

if (args.includeEnv) {

try {

const { envHeader } = await generateEnvTypes(

primaryConfig,

{ strictVars: args.strictVars },

args.envInterface,

typesPath,

entrypoint,

new Map(),

false // don't log anything

);

const newHash = envHeader?.match(/hash: (?<hash>.*)\)/)?.groups?.hash;

envOutOfDate = maybeExistingHash !== newHash;

} catch {

// If we can't generate env types for comparison, consider them out of date

envOutOfDate = true;

}

}

// Check if runtime types are out of date

if (args.includeRuntime) {

if (!primaryConfig.compatibility_date) {

// If no compatibility date, we can't check runtime types

runtimeOutOfDate = true;

} else {

const newRuntimeHeader = getRuntimeHeader(

version,

primaryConfig.compatibility_date,

primaryConfig.compatibility_flags

);

runtimeOutOfDate = existingRuntimeHeader !== newRuntimeHeader;

}

}

return envOutOfDate || runtimeOutOfDate;

line.startsWith(ENV_HEADER_COMMENT_PREFIX)

const newRuntimeHeader = getRuntimeHeader(

version,

config.compatibility_date ?? "",

config.compatibility_flags ?? []

);