@astralarium/repo-postgres 0.0.0-stage → 0.1.0

package/scripts/build-images.sh

@@ -0,0 +1,52 @@
+#!/usr/bin/env bash
+# Usage: build-images.sh <runtime> <schema-hash> [db|util|all] [db-iidfile]
+# <schema-hash>: labels the db image and stamps the initialized database
+#   volume; required for db and all, empty for util.
+# DB_NAME: the app's image base name (PostgresOptions.name); required.
+# DB_SCHEMA_DIR: the staged schema directory (schema.sql beside sql/, as
+#   `@astralarium/repo-postgres/provision` stageSchema writes it), baked into the db image.
+# DB_EXTENSIONS: extension names the db image installs, space-separated
+#   (Debian postgresql-<major>-<name> packages).
+# DB_REFRESH_BASE=true: pull the base images.
+set -euo pipefail
+
+cd "$( dirname "${BASH_SOURCE[0]}" )/.."
+
+DB_IMAGE=${DB_NAME:?set to the app image base name (PostgresOptions.name)}
+UTIL_IMAGE=$DB_IMAGE-util
+
+runtime=${1:?container runtime}
+hash=${2:-}
+target=${3:-all}
+case $target in
+    db|util|all) ;;
+    *) echo "build-images: unknown target $target (db, util or all)" >&2; exit 1 ;;
+esac
+build_args=(--file container/init/Containerfile)
+util_args=(--file container/util/Containerfile)
+if [[ ${DB_REFRESH_BASE:-false} == true ]]; then
+    build_args+=(--pull)
+    util_args+=(--pull)
+fi
+if [[ -n ${4:-} ]]; then
+    build_args+=(--iidfile "$4")
+fi
+
+if [[ $target == db || $target == all ]]; then
+    [[ -n $hash ]] || { echo "build-images: $target needs a schema hash" >&2; exit 1; }
+    schema_dir=${DB_SCHEMA_DIR:?staged schema directory}
+    [[ -f $schema_dir/schema.sql ]] || { echo "build-images: $schema_dir holds no schema.sql" >&2; exit 1; }
+    "$runtime" build container/init \
+        "${build_args[@]}" \
+        --build-context "schema=$schema_dir" \
+        --build-arg DB_EXTENSIONS="${DB_EXTENSIONS:-}" \
+        --build-arg DB_SCHEMA="$hash" \
+        --tag "$DB_IMAGE:$hash" \
+        --tag "$DB_IMAGE:latest" >&2
+fi
+
+if [[ $target == util || $target == all ]]; then
+    "$runtime" build container/util \
+        "${util_args[@]}" \
+        --tag "$UTIL_IMAGE:latest" >&2
+fi

package/scripts/dump-db.sh

@@ -0,0 +1,32 @@
+#!/usr/bin/env bash
+# Usage: postgres-dump-db > data.sql
+# Data-only dump of the PG* database via the util image, rebuilt on each
+# run (layer-cached); the replica role prefix skips triggers and FK checks
+# on load.
+# Source connection via PGHOST/PGPORT/PGUSER/PGPASSWORD/PGDATABASE.
+# DB_NAME: the app's image base name (PostgresOptions.name); required.
+# DB_DUMP_EXCLUDE: schema-qualified pg_dump table patterns whose rows stay
+#   out of the dump, space-separated (`app.session`, `app.*_log`); a
+#   partitioned table covers its partitions.
+# CONTAINER_RUNTIME: container runtime (default podman).
+set -euo pipefail
+
+runtime=${CONTAINER_RUNTIME:-podman}
+name=${DB_NAME:?set to the app image base name (PostgresOptions.name)}
+read -ra patterns <<< "${DB_DUMP_EXCLUDE:-}"
+for pattern in ${patterns[@]+"${patterns[@]}"}; do
+    [[ $pattern == *.* ]] || { echo "postgres-dump-db: DB_DUMP_EXCLUDE pattern $pattern lacks a schema" >&2; exit 1; }
+done
+
+# Through the real path: a package manager's bin link sits outside the package.
+scripts=$(dirname "$(realpath "${BASH_SOURCE[0]}")")
+bash "$scripts/build-images.sh" "$runtime" "" util
+
+"$runtime" run --rm --interactive \
+    --env PGHOST \
+    --env PGPORT \
+    --env PGUSER \
+    --env PGPASSWORD \
+    --env PGDATABASE \
+    --env DB_DUMP_EXCLUDE \
+    "$name-util" /entrypoint.d/dump-db.sh

package/sql/app/schema.sql

@@ -0,0 +1,8 @@
+-- The `app` schema: owned by app_admin, used by app_service.
+SET ROLE app_admin;
+
+CREATE SCHEMA app AUTHORIZATION app_admin;
+
+GRANT USAGE ON SCHEMA app TO app_service;
+
+SET ROLE NONE;

package/sql/bootstrap.sql

@@ -0,0 +1,27 @@
+-- Fresh remote (Neon) init: roles + app database + the app's schema.
+-- Local-container equivalent: container/init/entrypoint.d/init-db.sh (first boot).
+-- Run with psql from a staged schema directory (schema.sql beside sql/, as
+-- `@astralarium/repo-postgres/provision` stageSchema writes it), with -v pw=<app_service
+-- password>. With existing roles and database, use reset.sql.
+
+\i roles.sql
+-- app_service is the Hyperdrive origin login.
+ALTER USER app_service WITH PASSWORD :'pw';
+
+CREATE DATABASE app;
+
+-- Neon: extension objects are cloud_admin-owned, so the schema's per-object
+-- grants on them no-op. These stand in for them.
+DO $$
+BEGIN
+  IF to_regrole('neon_superuser') IS NOT NULL THEN
+    SET ROLE neon_superuser;
+    GRANT pg_read_all_data, pg_write_all_data TO app_admin;
+    RESET ROLE;
+  END IF;
+END $$;
+
+\connect app
+
+\i database-grants.sql
+\i schema.sql

package/sql/database-grants.sql

@@ -0,0 +1,3 @@
+-- Database grants of the app database psql is connected to.
+GRANT CREATE, CONNECT ON DATABASE :"DBNAME" TO app_admin;
+GRANT CONNECT ON DATABASE :"DBNAME" TO app_service;

package/sql/drop-schemas.sql

@@ -0,0 +1,11 @@
+-- Drops every schema the current role (app_admin, under reset.sql) owns.
+DO $$
+DECLARE
+  schema_name text;
+BEGIN
+  FOR schema_name IN
+    SELECT nspname FROM pg_namespace WHERE nspowner = to_regrole(current_user)
+  LOOP
+    EXECUTE format('DROP SCHEMA %I CASCADE', schema_name);
+  END LOOP;
+END $$;

package/sql/extensions/cron/schema.sql

@@ -0,0 +1,23 @@
+-- pg_cron in the database `cron.database_name` selects, with a daily
+-- `cron-history-ttl` deleting run history past 7 days. Skipped where
+-- pg_cron is not loaded: disposable instances run stock Postgres.
+DO $$
+BEGIN
+  IF current_setting('cron.database_name', true) IS NULL THEN
+    RAISE NOTICE 'pg_cron is not loaded; skipping';
+    RETURN;
+  END IF;
+
+  CREATE EXTENSION IF NOT EXISTS pg_cron;
+
+  PERFORM cron.schedule(
+    'cron-history-ttl',
+    '0 3 * * *',
+    $job$
+      SET statement_timeout = '30s';
+      DELETE FROM cron.job_run_details
+        WHERE end_time < CURRENT_TIMESTAMP - interval '7 days';
+    $job$
+  );
+END;
+$$;

package/sql/extensions/partman/before-reset.sql

@@ -0,0 +1,38 @@
+-- pg_partman outlives reset.sql's drop (cloud_admin-owned on Neon) and
+-- keeps what it owns: a surviving part_config row makes create_parent
+-- reject its parent on reload, and each parent's template table lives in
+-- partman's schema with its app-typed columns. Clears both for every
+-- schema the current role (app_admin, under reset.sql) owns, so the
+-- reload takes the new shape.
+DO $$
+DECLARE
+  partman text;
+  schema_name text;
+  template text;
+BEGIN
+  SELECT n.nspname INTO partman
+  FROM pg_extension e JOIN pg_namespace n ON n.oid = e.extnamespace
+  WHERE e.extname = 'pg_partman';
+
+  IF partman IS NULL THEN
+    RETURN;
+  END IF;
+
+  FOR schema_name IN
+    SELECT nspname FROM pg_namespace WHERE nspowner = to_regrole(current_user)
+  LOOP
+    FOR template IN
+      EXECUTE format(
+        'SELECT template_table FROM %I.part_config WHERE template_table IS NOT NULL AND split_part(parent_table, ''.'', 1) = %L',
+        partman, schema_name)
+    LOOP
+      EXECUTE format('DROP TABLE IF EXISTS %s', template);
+    END LOOP;
+    EXECUTE format(
+      'DELETE FROM %I.part_config_sub WHERE split_part(sub_parent, ''.'', 1) = %L',
+      partman, schema_name);
+    EXECUTE format(
+      'DELETE FROM %I.part_config WHERE split_part(parent_table, ''.'', 1) = %L',
+      partman, schema_name);
+  END LOOP;
+END $$;

package/sql/extensions/partman/schema.sql

@@ -0,0 +1,8 @@
+-- pg_partman in schema `partman`; app_admin creates and maintains parents.
+CREATE SCHEMA IF NOT EXISTS partman;
+CREATE EXTENSION IF NOT EXISTS pg_partman SCHEMA partman;
+
+GRANT USAGE, CREATE ON SCHEMA partman TO app_admin;
+GRANT EXECUTE ON ALL FUNCTIONS  IN SCHEMA partman TO app_admin;
+GRANT EXECUTE ON ALL PROCEDURES IN SCHEMA partman TO app_admin;
+GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA partman TO app_admin;

package/sql/extensions/trgm/schema.sql

@@ -0,0 +1 @@
+CREATE EXTENSION IF NOT EXISTS pg_trgm;

package/sql/reset.sql

@@ -0,0 +1,22 @@
+-- Drops every schema app_admin owns and reloads the app's schema, in one
+-- transaction. Roles, the `app` database and the app_service password
+-- survive, so the Hyperdrive origin keeps working.
+-- Run with psql from a staged schema directory (schema.sql beside sql/, as
+-- `@astralarium/repo-postgres/provision` stageSchema writes it).
+
+\connect app
+
+BEGIN;
+
+SET LOCAL ROLE app_admin;
+
+-- Each schema module's beforeReset, in load order.
+\i before-reset.sql
+
+\i drop-schemas.sql
+
+RESET ROLE;
+
+\i schema.sql
+
+COMMIT;

package/sql/roles.sql

@@ -0,0 +1,10 @@
+-- The app roles, ahead of the schema; they outlive reset.sql.
+-- Run by the image's init-db.sh and by bootstrap.sql.
+
+-- app_admin owns the schemas and is assumed via SET ROLE (NOLOGIN).
+CREATE ROLE app_admin NOLOGIN;
+-- app_service is the app's login.
+CREATE USER app_service;
+GRANT app_service TO app_admin;
+GRANT app_admin TO CURRENT_USER;
+ALTER ROLE app_service SET idle_in_transaction_session_timeout = '30s';