sequent 7.2.0 → 8.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 516eaa30164cf31340f225e671c48614fa5201fcd8af4da43082ec8fa594fdbe
-  data.tar.gz: b744ba69e6f339d77343d0a52fa42453545c0ac3056a3c85ab51dae2d6aa6332
+  metadata.gz: 0d84095b5eda544d3dbfdfd38abf47cea0b8ae4ac4fdbd71607ce16956761609
+  data.tar.gz: 5e39298de05259431cfeca107fd1f338c2122fae340b90b368ea4f2a7513d836
 SHA512:
-  metadata.gz: c9030ef57d0369dcb184609394f88ca165907a7b0cade5fb8b53109d71be8627c0c01270360ac1b84da5018056aafd13162d6363de42a74082ac2ce38b5a9e58
-  data.tar.gz: 78b6528040a273ae3fb2cd13c962bc9874157330b9bdb8dafa9997634f27e7861ba3db4871f1065aea45301396f156225b66de33ac0a25b69024b46903ceb676
+  metadata.gz: d65e5937db24cb49fd4070bdc5c5bc06034bc94f88af7a44dfc50072aa127db08f128df97471a8cee85e03e3b5f60e25219adba6fd84b25cc8d679d553123479
+  data.tar.gz: e43babde3e2348af5a13e080de89fe698acfc8ffadd32522a613742c6e128d297d7af8b5f7ab8e4b96f32fbbeb04954ab449dfb04a7632742623bc5afbb7ec98

data/bin/sequent

@@ -1,111 +1,10 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require_relative '../lib/sequent/generator'
+require 'gli'
+require 'tty-prompt'
+require_relative '../lib/version'
+require_relative '../lib/sequent/cli/app'
 
-command = ARGV[0].to_s.strip
-abort('Please specify a command. i.e. `sequent new myapp`') if command.empty?
-abort('Please specify a command. i.e. `sequent new myapp`') if ARGV[1..-1].empty?
-
-args = ARGV[1..-1].map(&:to_s).map(&:strip)
-
-def new_project(args)
-  arguments = args.dup
-  name = arguments.shift
-  abort('Please specify a directory name. i.e. `sequent new myapp`') if name.empty?
-
-  Sequent::Generator::Project.new(name).execute
-  puts <<~NEXTSTEPS
-
-    Success!
-
-    Your brand spanking new sequent app is waiting for you in:
-      #{File.expand_path(name, Dir.pwd)}
-
-    To finish setting up your app:
-      cd #{name}
-      bundle install
-      bundle exec rake sequent:db:create
-      bundle exec rake sequent:db:create_view_schema
-      bundle exec rake sequent:migrate:online
-      bundle exec rake sequent:migrate:offline
-
-    Run the example specs:
-      SEQUENT_ENV=test bundle exec rake sequent:db:create
-      bundle exec rspec spec
-
-    To generate new aggregates use:
-      sequent generate <aggregate_name>. e.g. sequent generate address
-
-    For more information see:
-      https://www.sequent.io
-
-    Happy coding!
-
-  NEXTSTEPS
-end
-
-def generate_aggregate(args)
-  arguments = args.dup
-  aggregate_name = arguments.shift
-  abort('Please specify an aggregate name. i.e. `sequent g aggregate user`') unless args_valid?(aggregate_name)
-
-  Sequent::Generator::Aggregate.new(aggregate_name).execute
-  puts "#{aggregate_name} aggregate has been generated"
-end
-
-def generate_command(args)
-  arguments = args.dup
-  aggregate_name = arguments.shift
-  command_name = arguments.shift
-  attrs = arguments
-
-  unless args_valid?(aggregate_name, command_name)
-    abort('Please specify an aggregate name and command name. i.e. `sequent g command user AddUser`')
-  end
-  Sequent::Generator::Command.new(aggregate_name, command_name, attrs).execute
-  puts "#{command_name} command has been added to #{aggregate_name}"
-end
-
-def generate_event(args)
-  arguments = args.dup
-  aggregate_name = arguments.shift
-  event_name = arguments.shift
-  attrs = arguments
-
-  abort('Please specify an aggregate name and event name. i.e. `sequent g event user AddUser`') unless args_valid?(
-    aggregate_name, event_name
-  )
-  Sequent::Generator::Event.new(aggregate_name, event_name, attrs).execute
-  puts "#{event_name} event has been added to #{aggregate_name}"
-end
-
-def generate(args)
-  arguments = args.dup
-  entity = arguments.shift
-  abort('Please specify a command. i.e. `sequent g aggregate user`') if entity.empty?
-
-  case entity
-  when 'aggregate'
-    generate_aggregate(arguments)
-  when 'command'
-    generate_command(arguments)
-  when 'event'
-    generate_event(arguments)
-  else
-    abort("Unknown argument #{entity} for `generate`. Try `sequent g aggregate user`")
-  end
-end
-
-def args_valid?(*args)
-  args.all?(&:present?)
-end
-
-case command
-when 'new'
-  new_project(args)
-when 'generate', 'g'
-  generate(args)
-else
-  abort("Unknown command #{command}. Try `sequent new myapp`")
-end
+exit_code = Sequent::Cli::App.run(ARGV)
+exit(exit_code)

data/db/sequent_8_migration.sql

@@ -0,0 +1,120 @@
+-- This script migrates a pre-sequent 8 database to the sequent 8 schema while preserving the data.
+-- It runs in a single transaction and when completed you can COMMIT or ROLLBACK the results.
+--
+-- To adjust the partitioning setup you can modify `./sequent_schema_partitions.sql`. By default
+-- only a single partition is present for each partitioned table, which works well for smaller
+-- (e.g. less than 10 Gigabytes) databases.
+--
+-- Ensure you test this on a copy of your production system to verify everything works and to
+-- get an indication of the required downtime for your system.
+
+\set ECHO all
+\set ON_ERROR_STOP
+\timing on
+
+SELECT clock_timestamp() AS migration_started_at \gset
+
+\echo Migration started at :migration_started_at
+
+SET work_mem TO '8MB';
+SET max_parallel_workers = 8;
+SET max_parallel_workers_per_gather = 8;
+SET max_parallel_maintenance_workers = 8;
+
+BEGIN;
+
+SET temp_tablespaces = 'pg_default';
+SET search_path TO sequent_schema;
+
+ALTER SEQUENCE command_records_id_seq OWNED BY NONE;
+ALTER SEQUENCE command_records_id_seq RENAME TO commands_id_seq;
+
+\ir ./sequent_schema_tables.sql
+\ir ./sequent_schema_partitions.sql
+
+INSERT INTO aggregate_types (type)
+SELECT DISTINCT aggregate_type
+  FROM sequent_schema.stream_records
+ ORDER BY 1;
+
+INSERT INTO event_types (type)
+SELECT DISTINCT event_type
+  FROM sequent_schema.event_records
+ WHERE event_type <> 'Sequent::Core::SnapshotEvent'
+ ORDER BY 1;
+
+INSERT INTO command_types (type)
+SELECT DISTINCT command_type
+  FROM sequent_schema.command_records
+ ORDER BY 1;
+
+ANALYZE aggregate_types, event_types, command_types;
+
+INSERT INTO aggregates (aggregate_id, aggregate_type_id, snapshot_threshold, created_at)
+SELECT aggregate_id, (SELECT t.id FROM aggregate_types t WHERE aggregate_type = t.type), snapshot_threshold, created_at AT TIME ZONE 'Europe/Amsterdam'
+  FROM stream_records;
+
+WITH e AS MATERIALIZED (
+  SELECT aggregate_id,
+         sequence_number,
+         command_record_id,
+         t.id AS event_type_id,
+         event_json::jsonb - '{aggregate_id,sequence_number}'::text[] AS event_json
+    FROM sequent_schema.event_records e
+    JOIN event_types t ON e.event_type = t.type
+)
+INSERT INTO events (aggregate_id, sequence_number, created_at, command_id, event_type_id, event_json)
+SELECT aggregate_id,
+       sequence_number,
+       (event_json->>'created_at')::timestamptz AS created_at,
+       command_record_id,
+       event_type_id,
+       event_json - 'created_at'
+  FROM e;
+
+WITH command AS MATERIALIZED (
+  SELECT c.id, created_at,
+         t.id AS command_type_id,
+         command_json::jsonb AS json
+    FROM sequent_schema.command_records c
+    JOIN command_types t ON t.type = c.command_type
+)
+INSERT INTO commands (
+  id, created_at, user_id, aggregate_id, command_type_id, command_json,
+  event_aggregate_id, event_sequence_number
+)
+SELECT id,
+       COALESCE((json->>'created_at')::timestamptz, created_at AT TIME ZONE 'Europe/Amsterdam'),
+       (json->>'user_id')::uuid,
+       (json->>'aggregate_id')::uuid,
+       command_type_id,
+       json - '{created_at,user_id,aggregate_id,event_aggregate_id,event_sequence_number}'::text[],
+       (json->>'event_aggregate_id')::uuid,
+       (json->>'event_sequence_number')::integer
+  FROM command;
+
+INSERT INTO aggregates_that_need_snapshots (aggregate_id, snapshot_sequence_number_high_water_mark, snapshot_outdated_at)
+SELECT aggregate_id, MAX(sequence_number), NOW()
+  FROM event_records
+ WHERE event_type = 'Sequent::Core::SnapshotEvent'
+ GROUP BY 1
+ ORDER BY 1;
+
+ALTER TABLE command_records RENAME TO old_command_records;
+ALTER TABLE event_records RENAME TO old_event_records;
+ALTER TABLE stream_records RENAME TO old_stream_records;
+
+\ir ./sequent_schema_indexes.sql
+
+\set ECHO none
+
+\ir ./sequent_pgsql.sql
+
+\set ECHO all
+
+SELECT clock_timestamp() AS migration_completed_at,
+       clock_timestamp() - :'migration_started_at'::timestamptz AS migration_duration \gset
+
+\echo Migration complated in :migration_duration (started at :migration_started_at, completed at :migration_completed_at)
+
+\echo execute ROLLBACK to abort, COMMIT to commit followed by VACUUM VERBOSE ANALYZE to ensure good performance

data/db/sequent_pgsql.sql

@@ -0,0 +1,416 @@
+DROP TYPE IF EXISTS aggregate_event_type CASCADE;
+CREATE TYPE aggregate_event_type AS (
+  aggregate_type text,
+  aggregate_id uuid,
+  events_partition_key text,
+  event_type text,
+  event_json jsonb
+);
+
+CREATE OR REPLACE FUNCTION enrich_command_json(command commands) RETURNS jsonb
+LANGUAGE plpgsql AS $$
+BEGIN
+  RETURN jsonb_build_object(
+      'command_type', (SELECT type FROM command_types WHERE command_types.id = command.command_type_id),
+      'created_at', command.created_at,
+      'user_id', command.user_id,
+      'aggregate_id', command.aggregate_id,
+      'event_aggregate_id', command.event_aggregate_id,
+      'event_sequence_number', command.event_sequence_number
+    )
+    || command.command_json;
+END
+$$;
+
+CREATE OR REPLACE FUNCTION enrich_event_json(event events) RETURNS jsonb
+LANGUAGE plpgsql AS $$
+BEGIN
+  RETURN jsonb_build_object(
+      'aggregate_id', event.aggregate_id,
+      'sequence_number', event.sequence_number,
+      'created_at', event.created_at
+    )
+    || event.event_json;
+END
+$$;
+
+CREATE OR REPLACE FUNCTION load_event(
+  _aggregate_id uuid,
+  _sequence_number integer
+) RETURNS SETOF aggregate_event_type
+LANGUAGE plpgsql AS $$
+BEGIN
+  RETURN QUERY SELECT aggregate_types.type,
+         a.aggregate_id,
+         a.events_partition_key,
+         event_types.type,
+         enrich_event_json(e)
+    FROM aggregates a
+        INNER JOIN events e ON (a.events_partition_key, a.aggregate_id) = (e.partition_key, e.aggregate_id)
+        INNER JOIN aggregate_types ON a.aggregate_type_id = aggregate_types.id
+        INNER JOIN event_types ON e.event_type_id = event_types.id
+   WHERE a.aggregate_id = _aggregate_id
+     AND e.sequence_number = _sequence_number;
+END;
+$$;
+
+CREATE OR REPLACE FUNCTION load_events(
+  _aggregate_ids jsonb,
+  _use_snapshots boolean DEFAULT TRUE,
+  _until timestamptz DEFAULT NULL
+) RETURNS SETOF aggregate_event_type
+LANGUAGE plpgsql AS $$
+DECLARE
+  _aggregate_id aggregates.aggregate_id%TYPE;
+BEGIN
+  FOR _aggregate_id IN SELECT * FROM jsonb_array_elements_text(_aggregate_ids) LOOP
+    -- Use a single query to avoid race condition with UPDATEs to the events partition key
+    -- in case transaction isolation level is lower than repeatable read (the default of
+    -- PostgreSQL is read committed).
+    RETURN QUERY WITH
+      aggregate AS (
+        SELECT aggregate_types.type, aggregate_id, events_partition_key
+          FROM aggregates
+          JOIN aggregate_types ON aggregate_type_id = aggregate_types.id
+         WHERE aggregate_id = _aggregate_id
+      ),
+      snapshot AS (
+        SELECT *
+          FROM snapshot_records
+         WHERE _use_snapshots
+           AND aggregate_id = _aggregate_id
+           AND (_until IS NULL OR created_at < _until)
+         ORDER BY sequence_number DESC LIMIT 1
+      )
+    (SELECT a.*, s.snapshot_type, s.snapshot_json FROM aggregate a, snapshot s)
+    UNION ALL
+    (SELECT a.*, event_types.type, enrich_event_json(e)
+       FROM aggregate a
+       JOIN events e ON (a.events_partition_key, a.aggregate_id) = (e.partition_key, e.aggregate_id)
+       JOIN event_types ON e.event_type_id = event_types.id
+      WHERE e.sequence_number >= COALESCE((SELECT sequence_number FROM snapshot), 0)
+        AND (_until IS NULL OR e.created_at < _until)
+      ORDER BY e.sequence_number ASC);
+  END LOOP;
+END;
+$$;
+
+CREATE OR REPLACE FUNCTION store_command(_command jsonb) RETURNS bigint
+LANGUAGE plpgsql AS $$
+DECLARE
+  _id commands.id%TYPE;
+  _command_json jsonb = _command->'command_json';
+BEGIN
+  IF NOT EXISTS (SELECT 1 FROM command_types t WHERE t.type = _command->>'command_type') THEN
+    -- Only try inserting if it doesn't exist to avoid exhausting the id sequence
+    INSERT INTO command_types (type)
+    VALUES (_command->>'command_type')
+     ON CONFLICT DO NOTHING;
+  END IF;
+
+  INSERT INTO commands (
+    created_at, user_id, aggregate_id, command_type_id, command_json,
+    event_aggregate_id, event_sequence_number
+  ) VALUES (
+    (_command->>'created_at')::timestamptz,
+    (_command_json->>'user_id')::uuid,
+    (_command_json->>'aggregate_id')::uuid,
+    (SELECT id FROM command_types WHERE type = _command->>'command_type'),
+    (_command->'command_json') - '{command_type,created_at,organization_id,user_id,aggregate_id,event_aggregate_id,event_sequence_number}'::text[],
+    (_command_json->>'event_aggregate_id')::uuid,
+    NULLIF(_command_json->'event_sequence_number', 'null'::jsonb)::integer
+  ) RETURNING id INTO STRICT _id;
+  RETURN _id;
+END;
+$$;
+
+CREATE OR REPLACE PROCEDURE store_events(_command jsonb, _aggregates_with_events jsonb)
+LANGUAGE plpgsql AS $$
+DECLARE
+  _command_id commands.id%TYPE;
+  _aggregate jsonb;
+  _events jsonb;
+  _aggregate_id aggregates.aggregate_id%TYPE;
+  _aggregate_row aggregates%ROWTYPE;
+  _provided_events_partition_key aggregates.events_partition_key%TYPE;
+  _events_partition_key aggregates.events_partition_key%TYPE;
+  _snapshot_outdated_at aggregates_that_need_snapshots.snapshot_outdated_at%TYPE;
+BEGIN
+  _command_id = store_command(_command);
+
+  WITH types AS (
+    SELECT DISTINCT row->0->>'aggregate_type' AS type
+      FROM jsonb_array_elements(_aggregates_with_events) AS row
+  )
+  INSERT INTO aggregate_types (type)
+  SELECT type FROM types
+   WHERE type NOT IN (SELECT type FROM aggregate_types)
+   ORDER BY 1
+      ON CONFLICT DO NOTHING;
+
+  WITH types AS (
+    SELECT DISTINCT events->>'event_type' AS type
+      FROM jsonb_array_elements(_aggregates_with_events) AS row
+           CROSS JOIN LATERAL jsonb_array_elements(row->1) AS events
+  )
+  INSERT INTO event_types (type)
+  SELECT type FROM types
+   WHERE type NOT IN (SELECT type FROM event_types)
+   ORDER BY 1
+      ON CONFLICT DO NOTHING;
+
+  FOR _aggregate, _events IN SELECT row->0, row->1 FROM jsonb_array_elements(_aggregates_with_events) AS row
+                             ORDER BY row->0->'aggregate_id', row->1->0->'event_json'->'sequence_number'
+  LOOP
+    _aggregate_id = _aggregate->>'aggregate_id';
+    _provided_events_partition_key = _aggregate->>'events_partition_key';
+    _snapshot_outdated_at = _aggregate->>'snapshot_outdated_at';
+
+    SELECT * INTO _aggregate_row FROM aggregates WHERE aggregate_id = _aggregate_id;
+    _events_partition_key = COALESCE(_provided_events_partition_key, _aggregate_row.events_partition_key, '');
+
+    INSERT INTO aggregates (aggregate_id, created_at, aggregate_type_id, events_partition_key)
+    VALUES (
+      _aggregate_id,
+      (_events->0->>'created_at')::timestamptz,
+      (SELECT id FROM aggregate_types WHERE type = _aggregate->>'aggregate_type'),
+      _events_partition_key
+    ) ON CONFLICT (aggregate_id)
+      DO UPDATE SET events_partition_key = EXCLUDED.events_partition_key
+              WHERE aggregates.events_partition_key IS DISTINCT FROM EXCLUDED.events_partition_key;
+
+    INSERT INTO events (partition_key, aggregate_id, sequence_number, created_at, command_id, event_type_id, event_json)
+    SELECT _events_partition_key,
+           _aggregate_id,
+           (event->'event_json'->'sequence_number')::integer,
+           (event->>'created_at')::timestamptz,
+           _command_id,
+           (SELECT id FROM event_types WHERE type = event->>'event_type'),
+           (event->'event_json') - '{aggregate_id,created_at,event_type,sequence_number}'::text[]
+      FROM jsonb_array_elements(_events) AS event;
+
+    IF _snapshot_outdated_at IS NOT NULL THEN
+      INSERT INTO aggregates_that_need_snapshots AS row (aggregate_id, snapshot_outdated_at)
+      VALUES (_aggregate_id, _snapshot_outdated_at)
+          ON CONFLICT (aggregate_id) DO UPDATE
+         SET snapshot_outdated_at = LEAST(row.snapshot_outdated_at, EXCLUDED.snapshot_outdated_at)
+       WHERE row.snapshot_outdated_at IS DISTINCT FROM EXCLUDED.snapshot_outdated_at;
+    END IF;
+  END LOOP;
+END;
+$$;
+
+CREATE OR REPLACE PROCEDURE store_snapshots(_snapshots jsonb)
+LANGUAGE plpgsql AS $$
+DECLARE
+  _aggregate_id uuid;
+  _snapshot jsonb;
+  _sequence_number snapshot_records.sequence_number%TYPE;
+BEGIN
+  FOR _snapshot IN SELECT * FROM jsonb_array_elements(_snapshots) LOOP
+    _aggregate_id = _snapshot->>'aggregate_id';
+    _sequence_number = _snapshot->'sequence_number';
+
+    INSERT INTO aggregates_that_need_snapshots AS row (aggregate_id, snapshot_sequence_number_high_water_mark)
+    VALUES (_aggregate_id, _sequence_number)
+        ON CONFLICT (aggregate_id) DO UPDATE
+       SET snapshot_sequence_number_high_water_mark =
+             GREATEST(row.snapshot_sequence_number_high_water_mark, EXCLUDED.snapshot_sequence_number_high_water_mark),
+           snapshot_outdated_at = NULL,
+           snapshot_scheduled_at = NULL;
+
+    INSERT INTO snapshot_records (aggregate_id, sequence_number, created_at, snapshot_type, snapshot_json)
+    VALUES (
+      _aggregate_id,
+      _sequence_number,
+      (_snapshot->>'created_at')::timestamptz,
+      _snapshot->>'snapshot_type',
+      _snapshot->'snapshot_json'
+    );
+  END LOOP;
+END;
+$$;
+
+CREATE OR REPLACE FUNCTION load_latest_snapshot(_aggregate_id uuid) RETURNS aggregate_event_type
+LANGUAGE SQL AS $$
+  SELECT (SELECT type FROM aggregate_types WHERE id = a.aggregate_type_id),
+         a.aggregate_id,
+         a.events_partition_key,
+         s.snapshot_type,
+         s.snapshot_json
+    FROM aggregates a JOIN snapshot_records s ON a.aggregate_id = s.aggregate_id
+   WHERE a.aggregate_id = _aggregate_id
+   ORDER BY s.sequence_number DESC
+   LIMIT 1;
+$$;
+
+CREATE OR REPLACE PROCEDURE delete_all_snapshots(_now timestamp with time zone DEFAULT NOW())
+LANGUAGE plpgsql AS $$
+BEGIN
+  UPDATE aggregates_that_need_snapshots
+     SET snapshot_outdated_at = _now
+   WHERE snapshot_outdated_at IS NULL;
+  DELETE FROM snapshot_records;
+END;
+$$;
+
+CREATE OR REPLACE PROCEDURE delete_snapshots_before(_aggregate_id uuid, _sequence_number integer, _now timestamp with time zone DEFAULT NOW())
+LANGUAGE plpgsql AS $$
+BEGIN
+  DELETE FROM snapshot_records
+   WHERE aggregate_id = _aggregate_id
+     AND sequence_number < _sequence_number;
+
+  UPDATE aggregates_that_need_snapshots
+     SET snapshot_outdated_at = _now
+   WHERE aggregate_id = _aggregate_id
+     AND snapshot_outdated_at IS NULL
+     AND NOT EXISTS (SELECT 1 FROM snapshot_records WHERE aggregate_id = _aggregate_id);
+END;
+$$;
+
+CREATE OR REPLACE FUNCTION aggregates_that_need_snapshots(_last_aggregate_id uuid, _limit integer)
+  RETURNS TABLE (aggregate_id uuid)
+LANGUAGE plpgsql AS $$
+BEGIN
+  RETURN QUERY SELECT a.aggregate_id
+    FROM aggregates_that_need_snapshots a
+   WHERE a.snapshot_outdated_at IS NOT NULL
+     AND (_last_aggregate_id IS NULL OR a.aggregate_id > _last_aggregate_id)
+   ORDER BY 1
+   LIMIT _limit;
+END;
+$$;
+
+CREATE OR REPLACE FUNCTION select_aggregates_for_snapshotting(_limit integer, _reschedule_snapshot_scheduled_before timestamp with time zone, _now timestamp with time zone DEFAULT NOW())
+  RETURNS TABLE (aggregate_id uuid)
+LANGUAGE plpgsql AS $$
+BEGIN
+  RETURN QUERY WITH scheduled AS MATERIALIZED (
+    SELECT a.aggregate_id
+      FROM aggregates_that_need_snapshots AS a
+     WHERE snapshot_outdated_at IS NOT NULL
+     ORDER BY snapshot_outdated_at ASC, snapshot_sequence_number_high_water_mark DESC, aggregate_id ASC
+     LIMIT _limit
+       FOR UPDATE
+   ) UPDATE aggregates_that_need_snapshots AS row
+        SET snapshot_scheduled_at = _now
+       FROM scheduled
+      WHERE row.aggregate_id = scheduled.aggregate_id
+        AND (row.snapshot_scheduled_at IS NULL OR row.snapshot_scheduled_at < _reschedule_snapshot_scheduled_before)
+    RETURNING row.aggregate_id;
+END;
+$$;
+
+CREATE OR REPLACE PROCEDURE permanently_delete_commands_without_events(_aggregate_id uuid, _organization_id uuid)
+LANGUAGE plpgsql AS $$
+BEGIN
+  IF _aggregate_id IS NULL AND _organization_id IS NULL THEN
+    RAISE EXCEPTION 'aggregate_id or organization_id must be specified to delete commands';
+  END IF;
+
+  DELETE FROM commands
+   WHERE (_aggregate_id IS NULL OR aggregate_id = _aggregate_id)
+     AND NOT EXISTS (SELECT 1 FROM events WHERE command_id = commands.id);
+END;
+$$;
+
+CREATE OR REPLACE PROCEDURE permanently_delete_event_streams(_aggregate_ids jsonb)
+LANGUAGE plpgsql AS $$
+BEGIN
+  DELETE FROM events
+   USING jsonb_array_elements_text(_aggregate_ids) AS ids (id)
+    JOIN aggregates ON ids.id::uuid = aggregates.aggregate_id
+   WHERE events.partition_key = aggregates.events_partition_key
+     AND events.aggregate_id = aggregates.aggregate_id;
+  DELETE FROM aggregates
+   USING jsonb_array_elements_text(_aggregate_ids) AS ids (id)
+   WHERE aggregates.aggregate_id = ids.id::uuid;
+END;
+$$;
+
+DROP VIEW IF EXISTS command_records;
+CREATE VIEW command_records (id, user_id, aggregate_id, command_type, command_json, created_at, event_aggregate_id, event_sequence_number) AS
+  SELECT id,
+         user_id,
+         aggregate_id,
+         (SELECT type FROM command_types WHERE command_types.id = command.command_type_id),
+         enrich_command_json(command),
+         created_at,
+         event_aggregate_id,
+         event_sequence_number
+    FROM commands command;
+
+DROP VIEW IF EXISTS event_records;
+CREATE VIEW event_records (aggregate_id, partition_key, sequence_number, created_at, event_type, event_json, command_record_id, xact_id) AS
+     SELECT aggregate.aggregate_id,
+            event.partition_key,
+            event.sequence_number,
+            event.created_at,
+            type.type,
+            enrich_event_json(event) AS event_json,
+            command_id,
+            event.xact_id
+       FROM events event
+       JOIN aggregates aggregate ON aggregate.aggregate_id = event.aggregate_id AND aggregate.events_partition_key = event.partition_key
+       JOIN event_types type ON event.event_type_id = type.id;
+
+DROP VIEW IF EXISTS stream_records;
+CREATE VIEW stream_records (aggregate_id, events_partition_key, aggregate_type, created_at) AS
+     SELECT aggregates.aggregate_id,
+            aggregates.events_partition_key,
+            aggregate_types.type,
+            aggregates.created_at
+       FROM aggregates JOIN aggregate_types ON aggregates.aggregate_type_id = aggregate_types.id;
+
+CREATE OR REPLACE FUNCTION save_events_on_delete_trigger() RETURNS TRIGGER AS $$
+BEGIN
+  INSERT INTO saved_event_records (operation, timestamp, "user", aggregate_id, partition_key, sequence_number, created_at, event_type, event_json, command_id, xact_id)
+  SELECT 'D',
+         statement_timestamp(),
+         user,
+         o.aggregate_id,
+         o.partition_key,
+         o.sequence_number,
+         o.created_at,
+         (SELECT type FROM event_types WHERE event_types.id = o.event_type_id),
+         o.event_json,
+         o.command_id,
+         o.xact_id
+    FROM old_table o;
+  RETURN NULL;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE OR REPLACE FUNCTION save_events_on_update_trigger() RETURNS TRIGGER AS $$
+BEGIN
+  INSERT INTO saved_event_records (operation, timestamp, "user", aggregate_id, partition_key, sequence_number, created_at, event_type, event_json, command_id, xact_id)
+  SELECT 'U',
+         statement_timestamp(),
+         user,
+         o.aggregate_id,
+         o.partition_key,
+         o.sequence_number,
+         o.created_at,
+         (SELECT type FROM event_types WHERE event_types.id = o.event_type_id),
+         o.event_json,
+         o.command_id,
+         o.xact_id
+    FROM old_table o LEFT JOIN new_table n ON o.aggregate_id = n.aggregate_id AND o.sequence_number = n.sequence_number
+   WHERE n IS NULL
+      -- Only save when event related information changes
+      OR o.created_at <> n.created_at
+      OR o.event_type_id <> n.event_type_id
+      OR o.event_json <> n.event_json;
+  RETURN NULL;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE OR REPLACE TRIGGER save_events_on_delete_trigger
+    AFTER DELETE ON events
+    REFERENCING OLD TABLE AS old_table
+    FOR EACH STATEMENT EXECUTE FUNCTION save_events_on_delete_trigger();
+CREATE OR REPLACE TRIGGER save_events_on_update_trigger
+    AFTER UPDATE ON events
+    REFERENCING OLD TABLE AS old_table NEW TABLE AS new_table
+    FOR EACH STATEMENT EXECUTE FUNCTION save_events_on_update_trigger();