@nspot/geo-engine 0.1.0

package/sql/005_packs.sql

@@ -0,0 +1,200 @@
+-- ============================================================================
+-- 005 — region packs: versioned region sets moved between databases
+-- ============================================================================
+
+CREATE TABLE geo.packs (
+  id             serial PRIMARY KEY,
+  slug           text NOT NULL UNIQUE,
+  version        text NOT NULL,
+  schema_version int  NOT NULL,
+  installed_at   timestamptz NOT NULL DEFAULT now()
+);
+
+ALTER TABLE geo.regions ADD COLUMN pack_id int REFERENCES geo.packs(id) ON DELETE SET NULL;
+CREATE INDEX regions_pack_idx ON geo.regions (pack_id);
+
+-- upsert_region now carries the pack it writes for. A region owned by a
+-- different pack (or by nobody, i.e. a local region) is never overwritten.
+DROP FUNCTION geo.upsert_region(text, text, text, geo.region_type, int, int, text, text[], jsonb, jsonb, boolean);
+CREATE OR REPLACE FUNCTION geo.upsert_region(
+  p_country_code text,
+  p_slug         text,
+  p_name         text,
+  p_type         geo.region_type,
+  p_level        int,
+  p_parent_id    int,
+  p_code         text,
+  p_tags         text[],
+  p_properties   jsonb,
+  p_geojson      jsonb,
+  p_upsert       boolean DEFAULT true,
+  p_pack_id      int DEFAULT NULL
+) RETURNS geo.regions
+LANGUAGE plpgsql AS $$
+DECLARE
+  r        geo.regions;
+  existing geo.regions;
+  cid      int;
+BEGIN
+  SELECT id INTO cid FROM geo.countries WHERE code = upper(p_country_code);
+  IF cid IS NULL THEN
+    RAISE EXCEPTION 'Unknown country code %', p_country_code USING ERRCODE = 'foreign_key_violation';
+  END IF;
+  SELECT * INTO existing FROM geo.regions WHERE country_id = cid AND slug = p_slug;
+  IF existing.id IS NOT NULL AND NOT p_upsert THEN
+    RAISE EXCEPTION 'A region with slug "%" already exists in %', p_slug, upper(p_country_code)
+      USING ERRCODE = 'unique_violation';
+  END IF;
+  IF existing.id IS NOT NULL AND existing.pack_id IS DISTINCT FROM p_pack_id THEN
+    RAISE EXCEPTION 'Region "%" in % belongs to % and cannot be changed here', p_slug, upper(p_country_code),
+      CASE WHEN existing.pack_id IS NULL THEN 'this database (local region)'
+           ELSE 'pack "' || (SELECT slug FROM geo.packs WHERE id = existing.pack_id) || '"' END
+      USING ERRCODE = 'unique_violation';
+  END IF;
+
+  INSERT INTO geo.regions (country_id, slug, name, type, level, parent_id, code, tags, properties, geom, pack_id)
+  VALUES (cid, p_slug, p_name, p_type, p_level, p_parent_id, p_code,
+          coalesce(p_tags, '{}'), coalesce(p_properties, '{}'), geo.geom_from_geojson_area(p_geojson), p_pack_id)
+  ON CONFLICT (country_id, slug) DO UPDATE
+    SET name       = EXCLUDED.name,
+        type       = EXCLUDED.type,
+        level      = EXCLUDED.level,
+        parent_id  = EXCLUDED.parent_id,
+        code       = EXCLUDED.code,
+        tags       = EXCLUDED.tags,
+        properties = EXCLUDED.properties,
+        geom       = EXCLUDED.geom,
+        pack_id    = EXCLUDED.pack_id
+  RETURNING * INTO r;
+  RETURN r;
+END $$;
+
+-- Everything in this database as one pack document (6-decimal coordinates).
+CREATE OR REPLACE FUNCTION geo.export_pack(p_slug text, p_version text) RETURNS jsonb
+LANGUAGE sql STABLE AS $$
+  SELECT jsonb_build_object(
+    'pack', jsonb_build_object(
+      'slug', p_slug, 'version', p_version, 'schema_version', geo.schema_version(),
+      'published_at', to_char(now() AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS"Z"')),
+    'countries', coalesce((
+      SELECT jsonb_agg(jsonb_build_object(
+        'code', c.code, 'name', c.name,
+        'geometry', CASE WHEN c.geom IS NULL THEN NULL ELSE ST_AsGeoJSON(c.geom, 6)::jsonb END
+      ) ORDER BY c.code)
+      FROM geo.countries c), '[]'::jsonb),
+    'regions', jsonb_build_object(
+      'type', 'FeatureCollection',
+      'features', coalesce((
+        SELECT jsonb_agg(jsonb_build_object(
+          'type', 'Feature',
+          'geometry', ST_AsGeoJSON(r.geom, 6)::jsonb,
+          'properties', jsonb_build_object(
+            'country', c.code, 'slug', r.slug, 'name', r.name, 'type', r.type, 'level', r.level,
+            'parent', p.slug, 'parent_country', pc.code, 'code', r.code, 'tags', to_jsonb(r.tags), 'properties', r.properties)
+        ) ORDER BY c.code, r.slug)
+        FROM geo.regions r
+        JOIN geo.countries c ON c.id = r.country_id
+        LEFT JOIN geo.regions p ON p.id = r.parent_id
+        LEFT JOIN geo.countries pc ON pc.id = p.country_id), '[]'::jsonb)));
+$$;
+
+-- Install or update a pack in one transaction. Membership triggers are
+-- suspended for the bulk write and the cache is rebuilt once at the end.
+CREATE OR REPLACE FUNCTION geo.install_pack(p_pack jsonb) RETURNS jsonb
+LANGUAGE plpgsql AS $$
+DECLARE
+  hdr         jsonb := p_pack->'pack';
+  feats       jsonb := coalesce(p_pack->'regions'->'features', '[]'::jsonb);
+  pid         int;
+  f           jsonb;
+  n_countries int := 0;
+  n_regions   int := 0;
+  n_members   bigint;
+  code        text;
+BEGIN
+  IF hdr IS NULL OR coalesce(hdr->>'slug', '') = '' OR coalesce(hdr->>'version', '') = '' THEN
+    RAISE EXCEPTION 'Pack header must have slug and version' USING ERRCODE = 'invalid_parameter_value';
+  END IF;
+  IF coalesce((hdr->>'schema_version')::int, 0) > geo.schema_version() THEN
+    RAISE EXCEPTION 'Pack "%" needs schema version % but this database has %',
+      hdr->>'slug', hdr->>'schema_version', geo.schema_version()
+      USING ERRCODE = 'invalid_parameter_value';
+  END IF;
+
+  INSERT INTO geo.packs (slug, version, schema_version)
+  VALUES (hdr->>'slug', hdr->>'version', coalesce((hdr->>'schema_version')::int, geo.schema_version()))
+  ON CONFLICT (slug) DO UPDATE
+    SET version = EXCLUDED.version, schema_version = EXCLUDED.schema_version, installed_at = now()
+  RETURNING id INTO pid;
+
+  PERFORM set_config('geo.skip_membership_triggers', 'on', true);
+
+  FOR f IN SELECT * FROM jsonb_array_elements(coalesce(p_pack->'countries', '[]'::jsonb)) LOOP
+    PERFORM geo.upsert_country(f->>'code', f->>'name',
+      CASE WHEN jsonb_typeof(f->'geometry') = 'object' THEN f->'geometry' END);
+    n_countries := n_countries + 1;
+  END LOOP;
+
+  FOR f IN SELECT * FROM jsonb_array_elements(feats) LOOP
+    PERFORM geo.upsert_region(
+      f->'properties'->>'country',
+      f->'properties'->>'slug',
+      f->'properties'->>'name',
+      (f->'properties'->>'type')::geo.region_type,
+      (f->'properties'->>'level')::int,
+      NULL,
+      f->'properties'->>'code',
+      ARRAY(SELECT jsonb_array_elements_text(coalesce(f->'properties'->'tags', '[]'::jsonb))),
+      coalesce(f->'properties'->'properties', '{}'::jsonb),
+      f->'geometry',
+      true,
+      pid);
+    n_regions := n_regions + 1;
+  END LOOP;
+
+  -- regions that left the pack
+  DELETE FROM geo.regions r
+  USING geo.countries c
+  WHERE r.pack_id = pid AND c.id = r.country_id
+    AND NOT EXISTS (
+      SELECT 1 FROM jsonb_array_elements(feats) ff
+      WHERE upper(ff->'properties'->>'country') = c.code AND ff->'properties'->>'slug' = r.slug);
+
+  -- parents by slug, now that every region of the pack exists. A parent may
+  -- live in another country (parent_country); it must belong to this same
+  -- pack, so a pack stays self-contained and never adopts a local region
+  -- that happens to share its parent's slug.
+  UPDATE geo.regions r
+  SET parent_id = par.id
+  FROM jsonb_array_elements(feats) ff
+  JOIN geo.countries c ON c.code = upper(ff->'properties'->>'country')
+  JOIN geo.countries pc ON pc.code = upper(coalesce(ff->'properties'->>'parent_country', ff->'properties'->>'country'))
+  JOIN geo.regions par ON par.country_id = pc.id AND par.slug = ff->'properties'->>'parent' AND par.pack_id = pid
+  WHERE r.pack_id = pid AND r.country_id = c.id AND r.slug = ff->'properties'->>'slug';
+
+  FOR code IN SELECT c.code FROM geo.countries c WHERE c.geom IS NULL LOOP
+    PERFORM geo.derive_country_geom(code);
+  END LOOP;
+
+  n_members := geo.rebuild_all_memberships();
+  PERFORM set_config('geo.skip_membership_triggers', 'off', true);
+  RETURN jsonb_build_object(
+    'pack', hdr->>'slug', 'version', hdr->>'version',
+    'countries', n_countries, 'regions', n_regions, 'memberships', n_members);
+END $$;
+
+CREATE OR REPLACE FUNCTION geo.uninstall_pack(p_slug text) RETURNS int
+LANGUAGE plpgsql AS $$
+DECLARE
+  pid int;
+  n   int;
+BEGIN
+  SELECT id INTO pid FROM geo.packs WHERE slug = p_slug;
+  IF pid IS NULL THEN
+    RAISE EXCEPTION 'Unknown pack "%"', p_slug USING ERRCODE = 'invalid_parameter_value';
+  END IF;
+  DELETE FROM geo.regions WHERE pack_id = pid;   -- memberships cascade
+  GET DIAGNOSTICS n = ROW_COUNT;
+  DELETE FROM geo.packs WHERE id = pid;
+  RETURN n;
+END $$;

package/sql/006_search_path.sql

@@ -0,0 +1,71 @@
+-- ============================================================================
+-- 006 — pin search_path on every function and procedure in schema geo
+--
+-- The engine calls PostGIS unqualified. Hosts may install PostGIS outside
+-- public (Supabase uses `extensions`) or connect with a search_path of their
+-- own, so each function carries its own path: geo first, then the schema
+-- that owns the postgis extension, then pg_temp. geom_expr fragments given to
+-- register_source therefore must qualify any non-PostGIS function they call.
+--
+-- Later migrations that CREATE OR REPLACE a function must end with
+--   SELECT geo.pin_search_path();
+--
+-- Pinning can break a geom_expr registered before this migration if it called a
+-- host function unqualified, so the migration ends by re-probing every stored
+-- geom_expr through geo.check_sources(): one WARNING per source that no longer
+-- compiles, and the count of them as the result. It never fails the migration —
+-- run `SELECT geo.check_sources();` again at any time to re-check.
+-- ============================================================================
+
+CREATE OR REPLACE FUNCTION geo.pin_search_path() RETURNS int
+LANGUAGE plpgsql AS $$
+DECLARE
+  postgis_schema text;
+  f record;
+  n int := 0;
+BEGIN
+  SELECT ns.nspname INTO postgis_schema
+  FROM pg_extension e JOIN pg_namespace ns ON ns.oid = e.extnamespace
+  WHERE e.extname = 'postgis';
+  IF postgis_schema IS NULL THEN
+    RAISE EXCEPTION 'The postgis extension is not installed' USING ERRCODE = 'undefined_object';
+  END IF;
+  FOR f IN
+    SELECT p.oid::regprocedure AS sig, p.prokind AS kind
+    FROM pg_proc p JOIN pg_namespace ns ON ns.oid = p.pronamespace
+    WHERE ns.nspname = 'geo' AND p.prokind IN ('f', 'p')
+  LOOP
+    IF f.kind = 'p' THEN
+      EXECUTE format('ALTER PROCEDURE %s SET search_path = geo, %I, pg_temp', f.sig, postgis_schema);
+    ELSE
+      EXECUTE format('ALTER FUNCTION %s SET search_path = geo, %I, pg_temp', f.sig, postgis_schema);
+    END IF;
+    n := n + 1;
+  END LOOP;
+  RETURN n;
+END $$;
+
+-- Re-run register_source's probe against every stored geom_expr. Pinned like every
+-- other geo function (pin_search_path() below covers it), so the probe compiles the
+-- expression under exactly the search_path the membership triggers will use.
+-- Returns the number of sources that failed; each one also raises a WARNING.
+CREATE OR REPLACE FUNCTION geo.check_sources() RETURNS int
+LANGUAGE plpgsql AS $$
+DECLARE
+  s      record;
+  failed int := 0;
+BEGIN
+  FOR s IN SELECT name, table_schema, table_name, geom_expr FROM geo.sources ORDER BY id
+  LOOP
+    BEGIN
+      EXECUTE format('SELECT (%s)::geometry FROM %I.%I r LIMIT 0', s.geom_expr, s.table_schema, s.table_name);
+    EXCEPTION WHEN OTHERS THEN
+      failed := failed + 1;
+      RAISE WARNING 'geo: source "%" geom_expr no longer compiles under the pinned search_path (%); qualify non-PostGIS functions and re-register it', s.name, SQLERRM;
+    END;
+  END LOOP;
+  RETURN failed;
+END $$;
+
+SELECT geo.pin_search_path();
+SELECT geo.check_sources();