@k2b/cloud 0.41.0 → 0.42.0

package/src/services/settings/store.ts

@@ -22,6 +22,10 @@ import { toPgTextArray } from "../postgres";
 import { requestCacheRedis } from "../request-cache-redis";
 import { decryptValue, encryptValue } from "./crypto";
 import { SETTINGS, SETTINGS_MAP, type SettingDef, validateSettingValue } from "./defaults";
+import { SettingUnreadableError } from "./errors";
+import { assertGeoBudgetPair } from "./geo-budget";
+
+export { SettingUnreadableError } from "./errors";
 
 const REDIS_KEY = (k: string) => `settings:${k}`;
 
@@ -30,16 +34,6 @@ type SqlClient = typeof sql;
 export type StoredSettingState = "none" | "readable" | "unreadable";
 export type SettingRead = { value: unknown; stored: StoredSettingState };
 
-export class SettingUnreadableError extends HTTPException {
-  readonly code = "setting_unreadable" as const;
-
-  constructor(readonly key: string) {
-    const message = `The stored value of setting "${key}" cannot be read by this application. Replace it with a new value or reset it to the default.`;
-    super(409, { message, res: Response.json({ code: "setting_unreadable", message }, { status: 409 }) });
-    this.name = "SettingUnreadableError";
-  }
-}
-
 /**
  * Forget cached values so every container re-reads on next access.
  *
@@ -83,8 +77,8 @@ const resolveFallback = (def: SettingDef | undefined): unknown => {
  */
 export const readKey = async (key: string): Promise<unknown> => (await bulkRead([key])).get(key);
 
-export const readKeyState = async (key: string): Promise<SettingRead> => {
-  const state = (await readStates([key])).get(key);
+export const readKeyState = async (key: string, db: SqlClient = sql): Promise<SettingRead> => {
+  const state = (await readStates([key], db)).get(key);
   if (!state) throw new Error(`Missing read state for setting "${key}"`);
   return state;
 };
@@ -155,10 +149,10 @@ export const bulkRead = async (keys: readonly string[]): Promise<Map<string, unk
  * State reads go directly to Postgres without reading or filling the cache;
  * value reads (`get`, snapshot) keep using the cache.
  */
-export const readStates = async (keys: readonly string[]): Promise<Map<string, SettingRead>> => {
+export const readStates = async (keys: readonly string[], db: SqlClient = sql): Promise<Map<string, SettingRead>> => {
   const result = new Map<string, SettingRead>();
   if (keys.length === 0) return result;
-  const rows = await sql<StoredRow[]>`SELECT key, value FROM settings.entries WHERE key = ANY(${toPgTextArray([...keys])}::text[])`;
+  const rows = await db<StoredRow[]>`SELECT key, value FROM settings.entries WHERE key = ANY(${toPgTextArray([...keys])}::text[])`;
   const byKey = new Map(rows.map((row) => [row.key, row]));
   for (const key of keys) {
     const row = byKey.get(key);
@@ -233,6 +227,8 @@ export const deleteLegacyKeys = async (extraKnownKeys: readonly string[] = []):
  * the caller explicitly replaces them. The row check and write share a transaction.
  * Lock with a no-op UPDATE so ROW EXCLUSIVE is acquired before the row lock,
  * preserving lock order with table-level SHARE locks (#1303 review).
+ * A caller passing `db` owns geo budget pair validation before mutations and
+ * cache invalidation after commit.
  */
 export const writeKey = async (key: string, value: unknown, db?: SqlClient, options?: { replaceUnreadable?: boolean }): Promise<void> => {
   const def = SETTINGS_MAP.get(key);
@@ -274,16 +270,28 @@ export const writeKey = async (key: string, value: unknown, db?: SqlClient, opti
     throw new Error(`Could not write setting "${key}" after 3 attempts`);
   };
   if (db) await write(db);
-  else await sql.begin(write);
+  else
+    await sql.begin(async (tx) => {
+      await assertGeoBudgetPair(tx, { [key]: validated.value }, []);
+      await write(tx);
+    });
 
   // Passing a transaction means the caller owns invalidation, because the row
   // is not visible to anyone else until they commit.
   if (!db) await invalidateSettingsCache([key]);
 };
 
-/** Delete the DB row and invalidate Redis. See writeKey for the `db` contract. */
+/** Delete the DB row and invalidate Redis. With `db`, the caller owns geo budget pair validation and post-commit invalidation. */
 export const deleteKey = async (key: string, db?: SqlClient): Promise<void> => {
-  await (db ?? sql)`DELETE FROM settings.entries WHERE key = ${key}`;
+  const remove = async (tx: SqlClient) => {
+    await tx`DELETE FROM settings.entries WHERE key = ${key}`;
+  };
+  if (db) await remove(db);
+  else
+    await sql.begin(async (tx) => {
+      await assertGeoBudgetPair(tx, {}, [key]);
+      await remove(tx);
+    });
   if (!db) await invalidateSettingsCache([key]);
 };
 

package/src/services/weather/geo.ts

@@ -1,123 +1,41 @@
-import { err, fail, ok, type PageParams, type Paginated, type Result } from "@k2b/stdlib";
-import { type GeoPlace, geoService } from "../../server";
-import * as settings from "../settings";
+import { err, fail, ok, type PageParams } from "@k2b/stdlib";
+import { geoClient } from "../../capabilities/geo-client";
+import type { CapabilityCaller } from "../../capabilities/server";
+import type { GeoProvenance } from "../../contracts/geo";
 
 export const WEATHER_COUNTRY_CODE = "DE";
+export type WeatherCity = { name: string; lat: number; lon: number; country?: string; state?: string; provenance: GeoProvenance };
 
-export type WeatherCity = {
-  name: string;
-  lat: number;
-  lon: number;
-  country?: string;
-  state?: string;
-};
-
-const unavailable = <T>(): Result<T> =>
-  fail({
-    code: "WEATHER_CITY_SEARCH_UNAVAILABLE",
-    message: "Weather city search is unavailable",
-    status: 500,
-  });
-
-/**
- * Adapts generic geo place data to the weather app's city model.
- */
-const mapPlace = (place: GeoPlace): WeatherCity => ({
-  name: place.name,
-  lat: place.lat,
-  lon: place.lon,
-  country: place.country,
-  state: place.state,
-});
-
-/**
- * Resolves and validates the configured geo service base URL.
- */
-const getGeoBaseUrl = async (): Promise<Result<string>> => {
-  const geoUrl = (await settings.get<string>("weather.geo_url")).trim();
-  if (!geoUrl) {
-    return fail({
-      code: "WEATHER_CITY_SEARCH_NOT_CONFIGURED",
-      message: "Geo API URL is not configured. Set weather.geo_url.",
-      status: 500,
-    });
-  }
-  return ok(geoUrl.replace(/\/$/, ""));
-};
-
-/**
- * Searches city candidates via the geo backend and enforces weather-specific country constraints.
- */
+/** Weather adapts Core's public address contract; only Core owns provider access and budgets. */
 const list = async (config: {
+  caller: CapabilityCaller;
   pagination?: PageParams;
   signal?: AbortSignal;
-  filter: {
-    query: string;
-    country?: string;
-  };
-}): Promise<Result<Paginated<WeatherCity>>> => {
+  filter: { query: string; country?: string };
+}) => {
   const query = config.filter.query.trim();
-  if (!query) {
-    return ok({
-      items: [],
-      page: config.pagination?.page ?? 1,
-      perPage: config.pagination?.perPage ?? 20,
-      total: 0,
-      hasNext: false,
-    });
-  }
-
-  const requestedCountry = config.filter.country?.trim().toUpperCase() ?? WEATHER_COUNTRY_CODE;
-  if (requestedCountry !== WEATHER_COUNTRY_CODE) {
+  const page = config.pagination?.page ?? 1;
+  const perPage = Math.min(5, config.pagination?.perPage ?? 5);
+  if ((config.filter.country?.trim().toUpperCase() ?? WEATHER_COUNTRY_CODE) !== WEATHER_COUNTRY_CODE)
     return fail(err.badInput("Only German city search is supported (country=DE)."));
-  }
-
-  const baseUrlResult = await getGeoBaseUrl();
-  if (!baseUrlResult.ok) return baseUrlResult;
-  const geoUrl = baseUrlResult.data;
-  const result = await geoService.place.list({
-    baseUrl: geoUrl,
-    pagination: config.pagination,
-    signal: config.signal,
-    filter: {
-      query,
-      country: WEATHER_COUNTRY_CODE,
-      featureClass: "P",
+  if (query.length < 3 || page > 1) return ok({ items: [], page, perPage, total: 0, hasNext: false });
+  const result = await geoClient.autocomplete(
+    { text: query, countryCode: WEATHER_COUNTRY_CODE, type: "city", limit: perPage },
+    {
+      ...config.caller,
+      signal: config.signal ?? config.caller.signal,
     },
-  });
-  if (!result.ok) return unavailable();
-
-  return ok({
-    ...result.data,
-    items: result.data.items.map(mapPlace),
-  });
-};
-
-/**
- * Resolves one place by coordinates via the geo backend.
- */
-const get = async (config: { lat: number; lon: number }): Promise<Result<WeatherCity | null>> => {
-  const baseUrlResult = await getGeoBaseUrl();
-  if (!baseUrlResult.ok) return baseUrlResult;
-  const result = await geoService.place.get({
-    baseUrl: baseUrlResult.data,
-    lat: config.lat,
-    lon: config.lon,
-  });
+  );
   if (!result.ok) return result;
-
-  const place = result.data;
-  if (!place) return ok(null);
-  if (place.featureClass !== undefined && place.featureClass !== "P") {
-    return ok(null);
-  }
-
-  return ok(mapPlace(place));
-};
-
-export const weatherCityService = {
-  list,
-  get,
+  const items = result.data.data.suggestions.map((address) => ({
+    name: address.city || address.formatted,
+    lat: address.point.lat,
+    lon: address.point.lon,
+    country: address.countryCode,
+    provenance: address.provenance,
+    ...(address.stateRegion ? { state: address.stateRegion } : {}),
+  }));
+  return ok({ items, page, perPage, total: items.length, hasNext: false });
 };
-
+export const weatherCityService = { list };
 export type WeatherCityService = typeof weatherCityService;

package/src/services/weather/index.ts

@@ -1,11 +1,11 @@
-import { err, fail, ok, type Result } from "@k2b/stdlib";
+import { err, fail, ok } from "@k2b/stdlib";
+import type { CapabilityCaller } from "../../capabilities/server";
 import { registerSettings, toLegacySettingDefs } from "../settings/defaults";
 import { getCurrentWeather, getWeatherData } from "./forecast";
 import { WEATHER_COUNTRY_CODE } from "./geo";
 import { weatherLocationService } from "./location";
 import { weatherLocationsService } from "./locations";
 import { WEATHER_SETTINGS } from "./settings";
-import type { WeatherData } from "./types";
 import { weatherUiService } from "./ui";
 
 registerSettings(toLegacySettingDefs(WEATHER_SETTINGS));
@@ -13,13 +13,14 @@ registerSettings(toLegacySettingDefs(WEATHER_SETTINGS));
 /**
  * Resolves a city name to coordinates and returns weather for the first match.
  */
-const getByCityName = async (config: { query: string }): Promise<Result<WeatherData>> => {
+const getByCityName = async (config: { query: string; caller: CapabilityCaller }) => {
   const query = config.query.trim();
   if (!query) {
     return fail(err.badInput("City query is required"));
   }
 
   const cityResult = await weatherLocationService.city.list({
+    caller: config.caller,
     pagination: { page: 1, perPage: 1 },
     filter: {
       query,

package/src/services/weather/locations.ts

@@ -1,5 +1,6 @@
 import { err, fail, ok, type PageParams, type Paginated, paginate, type Result } from "@k2b/stdlib";
 import { sql } from "bun";
+import type { GeoProvenance } from "../../contracts/geo";
 import { logger } from "../logging";
 import { withWeatherLocationShortId } from "./short-id";
 
@@ -11,6 +12,7 @@ export type Location = {
   state: string | null;
   lat: number;
   lon: number;
+  provenance?: GeoProvenance | null;
 };
 
 /**
@@ -23,6 +25,7 @@ const create = async (config: {
     state?: string;
     lat: number;
     lon: number;
+    provenance?: GeoProvenance;
   };
 }): Promise<Result<Location>> => {
   try {
@@ -30,10 +33,10 @@ const create = async (config: {
       await tx`SELECT pg_advisory_xact_lock(hashtext('cloud.weather.location-short-id-backfill'))`;
       return withWeatherLocationShortId(async (shortId) => {
         const [row] = await tx`
-          INSERT INTO weather_locations (short_id, user_id, name, state, lat, lon)
-          VALUES (${shortId}, ${config.userId}, ${config.data.name}, ${config.data.state ?? null}, ${config.data.lat}, ${config.data.lon})
+          INSERT INTO weather_locations (short_id, user_id, name, state, lat, lon, provenance)
+          VALUES (${shortId}, ${config.userId}, ${config.data.name}, ${config.data.state ?? null}, ${config.data.lat}, ${config.data.lon}, (${config.data.provenance ? JSON.stringify(config.data.provenance) : null}::text)::jsonb)
           ON CONFLICT (short_id) DO NOTHING
-          RETURNING short_id AS id, name, state, lat, lon
+          RETURNING short_id AS id, name, state, lat, lon, provenance
         `;
         return (row as Location | undefined) ?? null;
       });
@@ -93,7 +96,7 @@ const list = async (config: { userId: string; pagination?: PageParams; filter?:
   `;
 
   const items = (await sql`
-    SELECT short_id AS id, name, state, lat, lon
+    SELECT short_id AS id, name, state, lat, lon, provenance
     FROM weather_locations
     WHERE user_id = ${config.userId}
       AND ${queryMatch}
@@ -118,7 +121,7 @@ const list = async (config: { userId: string; pagination?: PageParams; filter?:
  */
 const get = async (config: { id: string; userId: string }): Promise<Location | null> => {
   const [location] = await sql`
-    SELECT short_id AS id, name, state, lat, lon
+    SELECT short_id AS id, name, state, lat, lon, provenance
     FROM weather_locations
     WHERE short_id = ${config.id} AND user_id = ${config.userId}
   `;

package/src/services/weather/migrate.ts

@@ -14,6 +14,7 @@ export const migrate = async (): Promise<void> => {
       created_at TIMESTAMPTZ NOT NULL DEFAULT now()
     )
   `.simple();
+  await sql`ALTER TABLE weather_locations ADD COLUMN IF NOT EXISTS provenance JSONB`.simple();
   console.log("  ✓ weather_locations table");
 
   await sql`ALTER TABLE weather_locations ADD COLUMN IF NOT EXISTS short_id TEXT`.simple();

package/src/services/weather/settings.ts

@@ -47,20 +47,4 @@ export const WEATHER_SETTINGS = {
       },
     },
   },
-  "weather.geo_url": {
-    kind: "url",
-    label: "Geo API URL",
-    default: "",
-    description: "Geocoding API URL for the location search feature",
-    placeholder: "e.g. https://geocoding.example.com/search",
-    presentation: {
-      translations: {
-        de: {
-          label: "Geo-API-URL",
-          description: "Geocoding-API-URL für die Ortssuche",
-          placeholder: "z. B. https://geocoding.example.com/search",
-        },
-      },
-    },
-  },
 } as const;

package/src/shared/__snapshots__/avatar-art.test.ts.snap

@@ -0,0 +1,5 @@
+// Bun Snapshot v1, https://bun.sh/docs/test/snapshots
+
+exports[`rendering keeps rendering a stored version 1 config byte for byte 1`] = `"7ac4c8231955f18292bccc1574886dff7fafb1453d6cbaf6d58f02452b65c4ff"`;
+
+exports[`rendering keeps rendering a stored version 1 config byte for byte 2`] = `"f2d19e9d678d902f9e7dcb85e0eb28ee95caaf28bd32e063d7dfd7bf21a7d4a6"`;