Fix your error. Get back to shipping.
Clear, tested fixes for the Next.js, Prisma, PostgreSQL, and Express errors that stop you cold at 2am.
Latest fixes
Loading articles...
Clear, tested fixes for the Next.js, Prisma, PostgreSQL, and Express errors that stop you cold at 2am.
Loading articles...
You're accessing a property that doesn't exist on the object's type — most often a typo, which TypeScript is helpfully guessing at with the "Did you mean" suggestion. Fix the spelling if it's a typo, or if the property genuinely should exist, check that you're importing/using the type you think you are (it may be a stale or differently-shaped version).
TypeScript 7's Go-native compiler ships as a separate package (`@typescript/native-preview`) with its own `tsgo` binary, distinct from the classic `tsc` command that `typescript` provides — installing `typescript` alone doesn't give you `tsgo`. Install the native-preview package explicitly and invoke `tsgo` (or its npx form) instead of expecting `tsc` to switch automatically.
With `verbatimModuleSyntax` enabled, TypeScript no longer decides for you whether an import is type-only or a real runtime import — it emits imports exactly as written. If you import something that's only ever used as a type, you must write `import type { X }` explicitly, since a regular `import { X }` would try to import a non-existent runtime value.
`"moduleResolution": "bundler"` (recommended for projects using Vite, esbuild, or similar) resolves modules the way real bundlers do, which is stricter about a package's `exports` field than the older `node` resolution mode was. A package resolving fine under `node` mode can fail under `bundler` mode if its `exports` map doesn't declare a `types` condition, or omits a subpath you're importing.
You're passing a type argument to a generic that doesn't satisfy the `extends` constraint the generic parameter declares. Check what the constraint actually requires (e.g. `T extends { id: string }`), and either pass a type that genuinely matches it, or loosen the constraint if it was written more narrowly than the function actually needs.
You're using `delete obj.prop` on a property that the object's type declares as required — TypeScript won't let you delete something that isn't allowed to be missing. Mark the property optional (`prop?: type`) if it's genuinely allowed to be absent, or set it to `undefined` instead of deleting it if the type must always have the key present.
Setting `"types": []` (now common with TypeScript 6.0+'s stricter defaults) stops TypeScript from automatically including every @types/* package in node_modules as a global — which also silently drops packages like @types/node that your code actually relies on globally (like `process`, `Buffer`). List the global type packages you need explicitly in the `types` array.
TypeScript 6.0 deprecated the standalone `baseUrl` option (used for non-relative module resolution) as part of aligning with 7.0's module resolution rewrite. Use explicit `paths` mappings anchored relative to the tsconfig file instead, which is more explicit and doesn't rely on an implicit resolution root.
TypeScript 7.0's Go-native compiler dropped support for several legacy compile targets and module systems as part of the rewrite, including `target: "es5"`. Set `target` to a modern value like `es2020` or later — virtually every environment still receiving updates in 2026 supports it natively, so this rarely needs a polyfill-based workaround.
TypeScript 6.0 (the bridge release ahead of the Go-native 7.0 compiler) turned on `strict: true` and several other options by default for new tsconfig.json files, and tightened behavior generally as part of aligning with 7.0. A project that relied on looser implicit defaults can suddenly surface dozens of previously-hidden errors. Explicitly set the options you actually want in tsconfig.json rather than relying on the previous implicit defaults.
You added a `// @ts-expect-error` comment above a line expecting it to suppress a type error, but the line no longer actually produces one — usually because a related fix elsewhere in the code resolved it. Unlike `@ts-ignore`, `@ts-expect-error` is meant to fail loudly once it's no longer needed; just delete the now-unnecessary directive.
Similar to "Object is possibly 'null'", but for values TypeScript has inferred could be `undefined` — commonly from optional properties, optional function parameters, or array/Map lookups that don't guarantee an element exists. Narrow with an `if` check or optional chaining before accessing a property, rather than reaching for a non-null assertion by default.