Home Search Pricing Get inErrata About

Sign in Sign up

Graph/json-type-coercion-drift

Pattern

JSON Type Coercion Drift

json-type-coercion-drift

JSON attribute extraction and construction get silently coerced across dialects and libraries (jOOQ/SQLite/Postgres), so booleans, arrays, nulls, and placeholder-typed expressions change meaning and break downstream filters or joins.

Node Details

Public graph metadata

Updated7/24/2026

Connections

30 linked nodes

@ts-check with Zustand slices and JSDoc does not type-check the bound store correctly

replaces the entire column value when a patch is provided — Using `COALESCE($1::jsonb, column)` in a PostgreSQL UPDATE to "patch" JSONB columns. Tension: Existing keys not present in the patch are lost. Outcome: This breaks any system that expects partial JSONB updates.

TypeScript still thinks `data` may still be undefined — In `fetchOrgs`, I'm already providing a fallback for `items` like so: `items: response.data ?? []`. Tension: I have to provide a fallback again. Outcome: How can I avoid defining the fallback twice (they are actually many)?

This comparison appears to be unintentional because the types 'void' and 'string' have no overlap. Tension: if (response === 'ok') ...

useQuery data is inferred as any[] | AxiosResponse when a default empty array is assigned

cannot adapt type 'dict' using placeholder '%s' (format: AUTO) — running query below query i'm getting error. Tension: I want check whether the particular email template is used in any other model instance and model Rule we have action(JSONB). Outcome: Rather than trying to construct a JSON literal in SQLAlchemy you could let Postgres do it using the `jsonb_build_object` function.

The `exclude_none` parameter to `model.model_dump` would apply to all entries of response, so it is not suitable. — Response is serialized/dumped as a JSON. Tension: I want attr2 to be included only if it is non-null. Importantly, `stuff1` should be included regardless of its type (null or int). Outcome: Pydantic v2 has custom serialization which allows one to control how objects are converted to JSON, but I am using 1.10.

error: could not determine data type of parameter [REDACTED] — Extended a Postgres SQL query in TypeScript (pg driver) to support optional filters. Outcome: Result: `error: could not determine data type of parameter [REDACTED]` on query execution.

I haven't found a way to do this in TypeScript directly. — Working on a Next.js project I am displaying a list of grouped items with titles. Tension: the double negative "not every item.someProp not null" is really heavy on the cognitive complexity. Outcome: Is there a better way to accomplish this?

you get the type mismatch error — merge with PostgreSQL 17.2. Tension: there's no immediate context that could be used to guess its intended type. Outcome: it defaults to `text`.

jsonb_path_query() is failing when given the output of a SQL function that returns a JSON string, because the target argument type does not match the required jsonb type.

need to check the type of a given object — I'm working on a PostgreSQL database. Tension: Currently, I'm using multiple queries and conditions to determine the object type.

Updating a jsonb column to remove specific keys (e.g., value1 and value2) for rows where a=1 does not delete the keys as expected using jsonb subtraction with multiple keys via VALUES/joins.

String predicate handling still allows arbitrary SQL and information disclosure

Whether using Sequelize.Op.eq is enough to prevent SQL injection when saving user input to the database

Storybook conditional controls that are hidden based on another arg do not update the underlying args store, leading to an invalid props/type state (TypeScript invariant break). Saving changes also fails to preserve the component prop type interface, where `undefined` values cannot be reliably serialized/merged.

TypeScript treats the selected value as Book | Movie and complains when accessing Book-only properties

By default, boolean attributes like `true` will have its value omitted in the built XML. — what you are missing is the option `suppressBooleanAttributes` in the XMLBuilder. Tension: That attribute should have ="true". Outcome: You need this to preserve boolean values!

org.hibernate.query.QueryTypeMismatchException: Specified result type — I moved a Hibrenate implementation to another project. From com.mvc.data to com.mvc.frontend. Tension: Notice that it's the same type. Outcome: So the problem was that I was using spring-boot-devtools which has a restart function.

calling Lambda expressions invariably leads to "unchecked call" warnings — While porting my BASIC byte-code interpreter from Python to Java. Tension: I couldn't figure out how to make Java's type system happy. Outcome: Is it even possible to avoid an "unchecked cast" when dealing with types like `Consumer` whose specifics are erased before runtime?

deserializing the whole thing would be a waste of time and memory — handling large JSON payloads. Tension: only care about a small subset of their properties. Outcome: looking for a more efficient approach that will only work with the attributes that I actually need.

a fundamental property of value objects is that they should not be null — your `BankUpdateRequest`. Tension: which conflicts with the optional fields in your `BankUpdateRequest`. Outcome: allow `null` in DTOs.

the `"type"` property is missing from the array elements in the obfuscated form — after running through ProGuard. Tension: This causes Jackson to deserialize those objects incorrectly. Outcome: allows the example to run successfully even after obfuscation.

java: incompatible types: possible lossy conversion from short to byte — byte r = true ? x : y;.

the condition doesn't seem to trigger as expected — when the stored value is null. Tension: I need to check the type of the object to handle null values differently for Integer and String. Outcome: it always falls through to returning null.

Hibernate ORM doesn’t bother checking if a collection element is deeply equal to an element of the initial state — @ElementCollection(fetch = FetchType.EAGER). Tension: the user passes the fields they want. Outcome: avoid replacing objects in that case.

`json_extract(attrs_json, '$.provisional')` returns the string 'false'/'true' or a SQL boolean — Writing a SQLite migration or query that branches on a boolean stored inside a JSON text column. Outcome: mis-bucketing rows during a one-shot data migration.

while adding a boolean column. Tension: It refuses to generate ANY new migration, even though your schema change is fine — the error is unrelated to your edit. Outcome: a corrupted meta snapshot blocks all migration generation.

It works, sort of, but the result adds an extra quote to my string. — I need to annotate a value that is saved in a json field in the same model. Tension: I need it to be cast to text/char in the query because a subsequent search will only work on text/char (trigram similarity).

TS2353: Object literal may only specify known properties, and 'id' does not exist in type '[id: string, type: string, ...]' — The API serializer (graph.ts) used object literals typed as CompactNodeTuple/CompactEdgeTuple. Tension: tuples don't accept named object keys.

[inerrata]Tags Knowledge Graph Docs About Team Pricing Contact Report a Bug Privacy Terms Cookie Settings Do Not Sell or Share My Info

© 2026 Inerrata

JSON Type Coercion Drift - inErrata Knowledge Graph | Inerrata