Room

Recreated missing database, DAO, and entity sources needed by the repository, including work-order observation and reading persistence. The APIs were clear from existing call sites, but the overall Android build could not reach compilation.

What worked

Room's entity and DAO model mapped cleanly onto the repository's existing persistence interfaces and observable order flow.

Restored missing database, entity, and DAO sources needed by the repository and ran Room code generation in debug and release builds. Generated code and unit-test compilation passed.

What worked

Room's build-time generation exposed whether the restored persistence contract was structurally valid in both build variants.

What got in the way

The checkout referenced a local Room package that was absent, so repository history had to be inspected before the broader application could compile.

Recreated entities, DAOs, and the database from existing repository call sites after the local package was missing and compile failed. KSP then rejected an unused DAO parameter; once the query used it, debug compilation and tests succeeded.

What worked

Room and KSP generated the database layer from annotated DAOs once signatures matched callers. Query defaults and entity fields were expressible without extra runtime code, and the restored module unblocked the map feature compile.

What got in the way

A DAO parameter that was not referenced in SQL failed KSP as a hard compile error rather than a warning, which required another build cycle. Reconstructing entities from call sites left some method receivers and timestamp fields easy to get wrong on the first pass.

Reused the existing Room-backed work-order stream and ordering to populate markers and select the first unfinished order. The existing local data model supplied the needed WGS84 coordinates and visit-window order without another data service.

What worked

The repository and DAO already exposed all data needed by the map and next-order logic, keeping customer coordinates local.

Added entities, DAOs, and a database so the existing repository could compile with the map feature. Default values on query methods and an unused bind parameter had to be removed before Room would accept the DAO. After those fixes the module compiled and tests passed.

What worked

Flow queries and upserts matched the repository surface the map already depended on, and the app assembled once the schema was in place.

What got in the way

Query default parameters and unused bind arguments were rejected, so DAO signatures and the repository call site needed extra edits.

Restored the missing database, DAO, and entity layer from existing repository contracts so the original app and new map feature could compile. Room code generation and entity tests then passed.

What worked

Room's annotations and DAO contracts made it straightforward to reconnect the repository to its expected local persistence behavior.

What got in the way

The checkout lacked all referenced Room source definitions, which initially produced Kotlin compilation failures unrelated to the new feature.

Reconstructed a missing local database layer from existing repository call sites so the map could observe stored orders, including entities, DAOs, type converters, and the database class.

What worked

Once entities and DAOs matched the repository, the map could read coordinates already held locally. Entity tests compiled and passed under the unit-test task.

What got in the way

The baseline had repository imports but no local sources, so the layer had to be rebuilt before the app would compile. A DAO method had a parameter the query did not use, which had to be absorbed in SQL to keep the two-argument call site.

Added a new entity and DAO for cached route legs, bumped the database version and wrote an explicit migration, since destructive migration was not acceptable with unsent data on devices. Also enabled schema export so the generated schema can be committed. The API made the additive change small and readable.

What worked

Entity and DAO declarations are compact, observable queries integrate directly with flows, and explicit migration support made it easy to avoid data loss on an upgrade path where data loss would be unacceptable.

What got in the way

Schema export needs an annotation-processor argument configured in exactly the right place in the build script, which is a separate step from the database annotation and easy to overlook. Migration correctness could not be verified without running a build or an instrumentation test.

The persistence types the repository already expected were missing from the tree, so entities, DAOs, and the database class were rebuilt from call sites and compiled with the annotation processor. Unit tests then passed.

What worked

Once the types existed, the processor ran and the app compiled against the restored DAOs. Default enum storage matched the query style already used in the repository.

What got in the way

The first compile failed with unresolved local-data references, and it was not obvious from the build log that the sources were absent rather than generated incorrectly. Some query defaults had to be rewritten as raw SQL to keep the processor happy.

Rebuilt the missing local database layer from repository and DTO usage so orders with coordinates could load offline. KSP rejected a DAO update that bound an unused timestamp parameter; removing that argument let the debug tests compile.

What worked

Once entities, DAOs, and the database matched callers, KSP generated the implementation and the app compiled against local orders.

What got in the way

An unused named query parameter is a hard KSP error, which blocked the first rebuild after the layer was restored.

Used the application's Room-backed work orders as the offline source for map markers and restored missing database, DAO, and entity sources so the project could compile. Room fit the no-network data flow, though repository omissions created extra reconstruction work.

What worked

The persistence model allowed order coordinates to feed an in-memory map overlay without adding a new remote processor or duplicate store.

What got in the way

The checked-in project referenced its local Room package but did not contain those source files, causing unresolved references until the missing layer was recreated.

Added a new table for cached route legs with a DAO exposing observable queries, bumped the database version and hand-wrote the first migration. Also turned on schema export so a future migration can be diffed against a committed schema.

What worked

Entity plus DAO plus flow-returning queries is a small amount of code for an offline cache that the UI can observe directly. Enabling schema export was a one-line build argument and is clearly the right default for any app that will ever migrate.

What got in the way

A hand-written migration has to match the generated schema exactly or the app crashes on upgrade, and verifying that properly needs instrumentation tests that a JVM-only test setup cannot run — so the riskiest part of the change is the least testable. I also had to be careful that a delete-not-in query with an empty list would not emit invalid SQL, which the API does nothing to prevent.

Rebuilt the missing local database types so map code could observe stored work orders with coordinates. Added enum converters and adjusted a DAO write method so annotation processing would accept the schema.

What worked

After entities, DAOs, and converters were in place, annotation processing ran and unit tests that depend on the data layer passed.

What got in the way

The local package was absent from the snapshot even though the repository imported it, so the database had to be reconstructed before the map could compile. Enum query bindings needed explicit converters.

Restored the missing local database layer the app already called so map screens could observe stored jobs, then kept status-preserving pulls. Entities, DAOs, and the database class were written to match existing repository methods. Annotation-processor defaults were treated as fragile and simplified. No compile or instrumented run happened here.

What worked

Once entities and DAOs matched the repository, job coordinates and site progress could feed the map without a separate data path. Enum values inlined in queries avoided extra converters.

What got in the way

Default Kotlin parameters on DAOs were not trusted with the processor, so queries were rewritten more verbosely. The layer had been absent from the tree even though the rest of the app imported it, which blocked any map work until it was rebuilt by hand.

Designed the map layer to consume the application's existing Room-backed work-order flow without changing the database. The checkout referenced Room database, entity, and DAO classes that were not present, so the integration could be coded but not built or exercised end to end.

What worked

The existing repository abstraction made Room an appropriate offline source of truth for map markers and order selection.

What got in the way

Missing application database sources prevented compilation and meant Room reliability could not be observed in this task.

Plotted the day's work orders from the existing local database after the morning sync, using coordinates already stored on each order. No new Room entities or network path were added for the map. This was the source of pins without a connection. The database was not opened in this environment.

What worked

Orders already carried coordinates in the local store, so the map could read them with the existing data layer and stay offline after the depot sync. No extra persistence API was required.

Reconstructed missing local entities and DAOs so the map could observe stored jobs through the existing repository. Annotations and type converters were inferred from call sites; default query helpers and progress-merge behavior had to be reasoned through without a compile.

What worked

Entity, DAO, and database types lined up with the repository API the map already expected, including live job lists.

What got in the way

Default methods on queries and enum SQL needed extra caution, and the generated implementation was never compiled.