panda-core 0.1.11 → 0.1.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4a61ca18a8280d264ca0f81f403fbedd427872848bfd73334c350205e7f9aa60
-  data.tar.gz: e637501064e17fedd6f287acd78a50e718737e39aa63138073b780dd4643546f
+  metadata.gz: cc545a266b233a065a0ad1400d61566033d676509364cbb0b3264cfebf1f937c
+  data.tar.gz: 1328107817e05bf72dd11dd0b3b27a3d39813b792ef2cd19b7e3d545d12a9df8
 SHA512:
-  metadata.gz: 2053ea6d1b6d8aeb58ce3ad4ee86b76add70f9c9cbc082acd208a1344f9048c1ea19e60ccb57de14c9ceb911f30b8b599ddeb3be59d5e4104c57705cc757acc6
-  data.tar.gz: 469d3de7cb13945f47402163b46d4c0f014235a5263e18ec525e6a08b4d7634f1170ac67ebc8f8496074ca8f0b07537515e68ad19006967e82d91ab3cc696f9f
+  metadata.gz: 221e370f59805011182520d1846637996517b080639dae1273814b8d44409bcc21b5af9b60f668acae9519a849407bb47f590f8c5ec29be35c67d743ad87dff5
+  data.tar.gz: 07bf703d37be3e11224154713566817eebe59e99660a902d52c2c7b77f050049fb8334ea501ba939e71537e12d33c6dc38130f02f7dbd6c9dd17713fcf4bbc9c

data/Rakefile

@@ -1,2 +1,7 @@
 require "bundler/setup"
+
+APP_RAKEFILE = File.expand_path("spec/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
+load "rails/tasks/statistics.rake"
+
 require "bundler/gem_tasks"

data/db/migrate/20250121012333_logidze_install.rb

@@ -0,0 +1,577 @@
+class LogidzeInstall < ActiveRecord::Migration[8.0]
+  def up
+    execute <<~SQL
+      CREATE OR REPLACE FUNCTION logidze_capture_exception(error_data jsonb) RETURNS boolean AS $body$
+        -- version: 1
+      BEGIN
+        -- Feel free to change this function to change Logidze behavior on exception.
+        --
+        -- Return `false` to raise exception or `true` to commit record changes.
+        --
+        -- `error_data` contains:
+        --   - returned_sqlstate
+        --   - message_text
+        --   - pg_exception_detail
+        --   - pg_exception_hint
+        --   - pg_exception_context
+        --   - schema_name
+        --   - table_name
+        -- Learn more about available keys:
+        -- https://www.postgresql.org/docs/9.6/plpgsql-control-structures.html#PLPGSQL-EXCEPTION-DIAGNOSTICS-VALUES
+        --
+
+        return false;
+      END;
+      $body$
+      LANGUAGE plpgsql;
+
+      CREATE OR REPLACE FUNCTION logidze_compact_history(log_data jsonb, cutoff integer DEFAULT 1) RETURNS jsonb AS $body$
+        -- version: 1
+        DECLARE
+          merged jsonb;
+        BEGIN
+          LOOP
+            merged := jsonb_build_object(
+              'ts',
+              log_data#>'{h,1,ts}',
+              'v',
+              log_data#>'{h,1,v}',
+              'c',
+              (log_data#>'{h,0,c}') || (log_data#>'{h,1,c}')
+            );
+
+            IF (log_data#>'{h,1}' ? 'm') THEN
+              merged := jsonb_set(merged, ARRAY['m'], log_data#>'{h,1,m}');
+            END IF;
+
+            log_data := jsonb_set(
+              log_data,
+              '{h}',
+              jsonb_set(
+                log_data->'h',
+                '{1}',
+                merged
+              ) - 0
+            );
+
+            cutoff := cutoff - 1;
+
+            EXIT WHEN cutoff <= 0;
+          END LOOP;
+
+          return log_data;
+        END;
+      $body$
+      LANGUAGE plpgsql;
+
+      CREATE OR REPLACE FUNCTION logidze_filter_keys(obj jsonb, keys text[], include_columns boolean DEFAULT false) RETURNS jsonb AS $body$
+        -- version: 1
+        DECLARE
+          res jsonb;
+          key text;
+        BEGIN
+          res := '{}';
+
+          IF include_columns THEN
+            FOREACH key IN ARRAY keys
+            LOOP
+              IF obj ? key THEN
+                res = jsonb_insert(res, ARRAY[key], obj->key);
+              END IF;
+            END LOOP;
+          ELSE
+            res = obj;
+            FOREACH key IN ARRAY keys
+            LOOP
+              res = res - key;
+            END LOOP;
+          END IF;
+
+          RETURN res;
+        END;
+      $body$
+      LANGUAGE plpgsql;
+
+      CREATE OR REPLACE FUNCTION logidze_logger() RETURNS TRIGGER AS $body$
+        -- version: 4
+        DECLARE
+          changes jsonb;
+          version jsonb;
+          full_snapshot boolean;
+          log_data jsonb;
+          new_v integer;
+          size integer;
+          history_limit integer;
+          debounce_time integer;
+          current_version integer;
+          k text;
+          iterator integer;
+          item record;
+          columns text[];
+          include_columns boolean;
+          ts timestamp with time zone;
+          ts_column text;
+          err_sqlstate text;
+          err_message text;
+          err_detail text;
+          err_hint text;
+          err_context text;
+          err_table_name text;
+          err_schema_name text;
+          err_jsonb jsonb;
+          err_captured boolean;
+        BEGIN
+          ts_column := NULLIF(TG_ARGV[1], 'null');
+          columns := NULLIF(TG_ARGV[2], 'null');
+          include_columns := NULLIF(TG_ARGV[3], 'null');
+
+          IF NEW.log_data is NULL OR NEW.log_data = '{}'::jsonb
+          THEN
+            IF columns IS NOT NULL THEN
+              log_data = logidze_snapshot(to_jsonb(NEW.*), ts_column, columns, include_columns);
+            ELSE
+              log_data = logidze_snapshot(to_jsonb(NEW.*), ts_column);
+            END IF;
+
+            IF log_data#>>'{h, -1, c}' != '{}' THEN
+              NEW.log_data := log_data;
+            END IF;
+
+          ELSE
+
+            IF TG_OP = 'UPDATE' AND (to_jsonb(NEW.*) = to_jsonb(OLD.*)) THEN
+              RETURN NEW; -- pass
+            END IF;
+
+            history_limit := NULLIF(TG_ARGV[0], 'null');
+            debounce_time := NULLIF(TG_ARGV[4], 'null');
+
+            log_data := NEW.log_data;
+
+            current_version := (log_data->>'v')::int;
+
+            IF ts_column IS NULL THEN
+              ts := statement_timestamp();
+            ELSEIF TG_OP = 'UPDATE' THEN
+              ts := (to_jsonb(NEW.*) ->> ts_column)::timestamp with time zone;
+              IF ts IS NULL OR ts = (to_jsonb(OLD.*) ->> ts_column)::timestamp with time zone THEN
+                ts := statement_timestamp();
+              END IF;
+            ELSEIF TG_OP = 'INSERT' THEN
+              ts := (to_jsonb(NEW.*) ->> ts_column)::timestamp with time zone;
+              IF ts IS NULL OR (extract(epoch from ts) * 1000)::bigint = (NEW.log_data #>> '{h,-1,ts}')::bigint THEN
+                ts := statement_timestamp();
+              END IF;
+            END IF;
+
+            full_snapshot := (coalesce(current_setting('logidze.full_snapshot', true), '') = 'on') OR (TG_OP = 'INSERT');
+
+            IF current_version < (log_data#>>'{h,-1,v}')::int THEN
+              iterator := 0;
+              FOR item in SELECT * FROM jsonb_array_elements(log_data->'h')
+              LOOP
+                IF (item.value->>'v')::int > current_version THEN
+                  log_data := jsonb_set(
+                    log_data,
+                    '{h}',
+                    (log_data->'h') - iterator
+                  );
+                END IF;
+                iterator := iterator + 1;
+              END LOOP;
+            END IF;
+
+            changes := '{}';
+
+            IF full_snapshot THEN
+              BEGIN
+                changes = hstore_to_jsonb_loose(hstore(NEW.*));
+              EXCEPTION
+                WHEN NUMERIC_VALUE_OUT_OF_RANGE THEN
+                  changes = row_to_json(NEW.*)::jsonb;
+                  FOR k IN (SELECT key FROM jsonb_each(changes))
+                  LOOP
+                    IF jsonb_typeof(changes->k) = 'object' THEN
+                      changes = jsonb_set(changes, ARRAY[k], to_jsonb(changes->>k));
+                    END IF;
+                  END LOOP;
+              END;
+            ELSE
+              BEGIN
+                changes = hstore_to_jsonb_loose(
+                      hstore(NEW.*) - hstore(OLD.*)
+                  );
+              EXCEPTION
+                WHEN NUMERIC_VALUE_OUT_OF_RANGE THEN
+                  changes = (SELECT
+                    COALESCE(json_object_agg(key, value), '{}')::jsonb
+                    FROM
+                    jsonb_each(row_to_json(NEW.*)::jsonb)
+                    WHERE NOT jsonb_build_object(key, value) <@ row_to_json(OLD.*)::jsonb);
+                  FOR k IN (SELECT key FROM jsonb_each(changes))
+                  LOOP
+                    IF jsonb_typeof(changes->k) = 'object' THEN
+                      changes = jsonb_set(changes, ARRAY[k], to_jsonb(changes->>k));
+                    END IF;
+                  END LOOP;
+              END;
+            END IF;
+
+            changes = changes - 'log_data';
+
+            IF columns IS NOT NULL THEN
+              changes = logidze_filter_keys(changes, columns, include_columns);
+            END IF;
+
+            IF changes = '{}' THEN
+              RETURN NEW; -- pass
+            END IF;
+
+            new_v := (log_data#>>'{h,-1,v}')::int + 1;
+
+            size := jsonb_array_length(log_data->'h');
+            version := logidze_version(new_v, changes, ts);
+
+            IF (
+              debounce_time IS NOT NULL AND
+              (version->>'ts')::bigint - (log_data#>'{h,-1,ts}')::text::bigint <= debounce_time
+            ) THEN
+              -- merge new version with the previous one
+              new_v := (log_data#>>'{h,-1,v}')::int;
+              version := logidze_version(new_v, (log_data#>'{h,-1,c}')::jsonb || changes, ts);
+              -- remove the previous version from log
+              log_data := jsonb_set(
+                log_data,
+                '{h}',
+                (log_data->'h') - (size - 1)
+              );
+            END IF;
+
+            log_data := jsonb_set(
+              log_data,
+              ARRAY['h', size::text],
+              version,
+              true
+            );
+
+            log_data := jsonb_set(
+              log_data,
+              '{v}',
+              to_jsonb(new_v)
+            );
+
+            IF history_limit IS NOT NULL AND history_limit <= size THEN
+              log_data := logidze_compact_history(log_data, size - history_limit + 1);
+            END IF;
+
+            NEW.log_data := log_data;
+          END IF;
+
+          RETURN NEW; -- result
+        EXCEPTION
+          WHEN OTHERS THEN
+            GET STACKED DIAGNOSTICS err_sqlstate = RETURNED_SQLSTATE,
+                                    err_message = MESSAGE_TEXT,
+                                    err_detail = PG_EXCEPTION_DETAIL,
+                                    err_hint = PG_EXCEPTION_HINT,
+                                    err_context = PG_EXCEPTION_CONTEXT,
+                                    err_schema_name = SCHEMA_NAME,
+                                    err_table_name = TABLE_NAME;
+            err_jsonb := jsonb_build_object(
+              'returned_sqlstate', err_sqlstate,
+              'message_text', err_message,
+              'pg_exception_detail', err_detail,
+              'pg_exception_hint', err_hint,
+              'pg_exception_context', err_context,
+              'schema_name', err_schema_name,
+              'table_name', err_table_name
+            );
+            err_captured = logidze_capture_exception(err_jsonb);
+            IF err_captured THEN
+              return NEW;
+            ELSE
+              RAISE;
+            END IF;
+        END;
+      $body$
+      LANGUAGE plpgsql;
+
+      CREATE OR REPLACE FUNCTION logidze_logger_after() RETURNS TRIGGER AS $body$
+        -- version: 4
+
+
+        DECLARE
+          changes jsonb;
+          version jsonb;
+          full_snapshot boolean;
+          log_data jsonb;
+          new_v integer;
+          size integer;
+          history_limit integer;
+          debounce_time integer;
+          current_version integer;
+          k text;
+          iterator integer;
+          item record;
+          columns text[];
+          include_columns boolean;
+          ts timestamp with time zone;
+          ts_column text;
+          err_sqlstate text;
+          err_message text;
+          err_detail text;
+          err_hint text;
+          err_context text;
+          err_table_name text;
+          err_schema_name text;
+          err_jsonb jsonb;
+          err_captured boolean;
+        BEGIN
+          ts_column := NULLIF(TG_ARGV[1], 'null');
+          columns := NULLIF(TG_ARGV[2], 'null');
+          include_columns := NULLIF(TG_ARGV[3], 'null');
+
+          IF NEW.log_data is NULL OR NEW.log_data = '{}'::jsonb
+          THEN
+            IF columns IS NOT NULL THEN
+              log_data = logidze_snapshot(to_jsonb(NEW.*), ts_column, columns, include_columns);
+            ELSE
+              log_data = logidze_snapshot(to_jsonb(NEW.*), ts_column);
+            END IF;
+
+            IF log_data#>>'{h, -1, c}' != '{}' THEN
+              NEW.log_data := log_data;
+            END IF;
+
+          ELSE
+
+            IF TG_OP = 'UPDATE' AND (to_jsonb(NEW.*) = to_jsonb(OLD.*)) THEN
+              RETURN NULL;
+            END IF;
+
+            history_limit := NULLIF(TG_ARGV[0], 'null');
+            debounce_time := NULLIF(TG_ARGV[4], 'null');
+
+            log_data := NEW.log_data;
+
+            current_version := (log_data->>'v')::int;
+
+            IF ts_column IS NULL THEN
+              ts := statement_timestamp();
+            ELSEIF TG_OP = 'UPDATE' THEN
+              ts := (to_jsonb(NEW.*) ->> ts_column)::timestamp with time zone;
+              IF ts IS NULL OR ts = (to_jsonb(OLD.*) ->> ts_column)::timestamp with time zone THEN
+                ts := statement_timestamp();
+              END IF;
+            ELSEIF TG_OP = 'INSERT' THEN
+              ts := (to_jsonb(NEW.*) ->> ts_column)::timestamp with time zone;
+              IF ts IS NULL OR (extract(epoch from ts) * 1000)::bigint = (NEW.log_data #>> '{h,-1,ts}')::bigint THEN
+                ts := statement_timestamp();
+              END IF;
+            END IF;
+
+            full_snapshot := (coalesce(current_setting('logidze.full_snapshot', true), '') = 'on') OR (TG_OP = 'INSERT');
+
+            IF current_version < (log_data#>>'{h,-1,v}')::int THEN
+              iterator := 0;
+              FOR item in SELECT * FROM jsonb_array_elements(log_data->'h')
+              LOOP
+                IF (item.value->>'v')::int > current_version THEN
+                  log_data := jsonb_set(
+                    log_data,
+                    '{h}',
+                    (log_data->'h') - iterator
+                  );
+                END IF;
+                iterator := iterator + 1;
+              END LOOP;
+            END IF;
+
+            changes := '{}';
+
+            IF full_snapshot THEN
+              BEGIN
+                changes = hstore_to_jsonb_loose(hstore(NEW.*));
+              EXCEPTION
+                WHEN NUMERIC_VALUE_OUT_OF_RANGE THEN
+                  changes = row_to_json(NEW.*)::jsonb;
+                  FOR k IN (SELECT key FROM jsonb_each(changes))
+                  LOOP
+                    IF jsonb_typeof(changes->k) = 'object' THEN
+                      changes = jsonb_set(changes, ARRAY[k], to_jsonb(changes->>k));
+                    END IF;
+                  END LOOP;
+              END;
+            ELSE
+              BEGIN
+                changes = hstore_to_jsonb_loose(
+                      hstore(NEW.*) - hstore(OLD.*)
+                  );
+              EXCEPTION
+                WHEN NUMERIC_VALUE_OUT_OF_RANGE THEN
+                  changes = (SELECT
+                    COALESCE(json_object_agg(key, value), '{}')::jsonb
+                    FROM
+                    jsonb_each(row_to_json(NEW.*)::jsonb)
+                    WHERE NOT jsonb_build_object(key, value) <@ row_to_json(OLD.*)::jsonb);
+                  FOR k IN (SELECT key FROM jsonb_each(changes))
+                  LOOP
+                    IF jsonb_typeof(changes->k) = 'object' THEN
+                      changes = jsonb_set(changes, ARRAY[k], to_jsonb(changes->>k));
+                    END IF;
+                  END LOOP;
+              END;
+            END IF;
+
+            changes = changes - 'log_data';
+
+            IF columns IS NOT NULL THEN
+              changes = logidze_filter_keys(changes, columns, include_columns);
+            END IF;
+
+            IF changes = '{}' THEN
+              RETURN NULL;
+            END IF;
+
+            new_v := (log_data#>>'{h,-1,v}')::int + 1;
+
+            size := jsonb_array_length(log_data->'h');
+            version := logidze_version(new_v, changes, ts);
+
+            IF (
+              debounce_time IS NOT NULL AND
+              (version->>'ts')::bigint - (log_data#>'{h,-1,ts}')::text::bigint <= debounce_time
+            ) THEN
+              -- merge new version with the previous one
+              new_v := (log_data#>>'{h,-1,v}')::int;
+              version := logidze_version(new_v, (log_data#>'{h,-1,c}')::jsonb || changes, ts);
+              -- remove the previous version from log
+              log_data := jsonb_set(
+                log_data,
+                '{h}',
+                (log_data->'h') - (size - 1)
+              );
+            END IF;
+
+            log_data := jsonb_set(
+              log_data,
+              ARRAY['h', size::text],
+              version,
+              true
+            );
+
+            log_data := jsonb_set(
+              log_data,
+              '{v}',
+              to_jsonb(new_v)
+            );
+
+            IF history_limit IS NOT NULL AND history_limit <= size THEN
+              log_data := logidze_compact_history(log_data, size - history_limit + 1);
+            END IF;
+
+            NEW.log_data := log_data;
+          END IF;
+
+              EXECUTE format('UPDATE %I.%I SET "log_data" = $1 WHERE ctid = %L', TG_TABLE_SCHEMA, TG_TABLE_NAME, NEW.CTID) USING NEW.log_data;
+          RETURN NULL;
+        EXCEPTION
+          WHEN OTHERS THEN
+            GET STACKED DIAGNOSTICS err_sqlstate = RETURNED_SQLSTATE,
+                                    err_message = MESSAGE_TEXT,
+                                    err_detail = PG_EXCEPTION_DETAIL,
+                                    err_hint = PG_EXCEPTION_HINT,
+                                    err_context = PG_EXCEPTION_CONTEXT,
+                                    err_schema_name = SCHEMA_NAME,
+                                    err_table_name = TABLE_NAME;
+            err_jsonb := jsonb_build_object(
+              'returned_sqlstate', err_sqlstate,
+              'message_text', err_message,
+              'pg_exception_detail', err_detail,
+              'pg_exception_hint', err_hint,
+              'pg_exception_context', err_context,
+              'schema_name', err_schema_name,
+              'table_name', err_table_name
+            );
+            err_captured = logidze_capture_exception(err_jsonb);
+            IF err_captured THEN
+              return NEW;
+            ELSE
+              RAISE;
+            END IF;
+        END;
+      $body$
+      LANGUAGE plpgsql;
+
+
+      CREATE OR REPLACE FUNCTION logidze_snapshot(item jsonb, ts_column text DEFAULT NULL, columns text[] DEFAULT NULL, include_columns boolean DEFAULT false) RETURNS jsonb AS $body$
+        -- version: 3
+        DECLARE
+          ts timestamp with time zone;
+          k text;
+        BEGIN
+          item = item - 'log_data';
+          IF ts_column IS NULL THEN
+            ts := statement_timestamp();
+          ELSE
+            ts := coalesce((item->>ts_column)::timestamp with time zone, statement_timestamp());
+          END IF;
+
+          IF columns IS NOT NULL THEN
+            item := logidze_filter_keys(item, columns, include_columns);
+          END IF;
+
+          FOR k IN (SELECT key FROM jsonb_each(item))
+          LOOP
+            IF jsonb_typeof(item->k) = 'object' THEN
+              item := jsonb_set(item, ARRAY[k], to_jsonb(item->>k));
+            END IF;
+          END LOOP;
+
+          return json_build_object(
+            'v', 1,
+            'h', jsonb_build_array(
+                    logidze_version(1, item, ts)
+                  )
+            );
+        END;
+      $body$
+      LANGUAGE plpgsql;
+
+      CREATE OR REPLACE FUNCTION logidze_version(v bigint, data jsonb, ts timestamp with time zone) RETURNS jsonb AS $body$
+        -- version: 2
+        DECLARE
+          buf jsonb;
+        BEGIN
+          data = data - 'log_data';
+          buf := jsonb_build_object(
+                    'ts',
+                    (extract(epoch from ts) * 1000)::bigint,
+                    'v',
+                    v,
+                    'c',
+                    data
+                    );
+          IF coalesce(current_setting('logidze.meta', true), '') <> '' THEN
+            buf := jsonb_insert(buf, '{m}', current_setting('logidze.meta')::jsonb);
+          END IF;
+          RETURN buf;
+        END;
+      $body$
+      LANGUAGE plpgsql;
+
+    SQL
+  end
+end
+
+def down
+  execute <<~SQL
+    DROP FUNCTION IF EXISTS logidze_capture_exception(jsonb) CASCADE;
+    DROP FUNCTION IF EXISTS logidze_compact_history(jsonb, integer) CASCADE;
+    DROP FUNCTION IF EXISTS logidze_filter_keys(jsonb, text[], boolean) CASCADE;
+    DROP FUNCTION IF EXISTS logidze_logger() CASCADE;
+    DROP FUNCTION IF EXISTS logidze_logger_after() CASCADE;
+    DROP FUNCTION IF EXISTS logidze_snapshot(jsonb, text, text[], boolean) CASCADE;
+    DROP FUNCTION IF EXISTS logidze_version(bigint, jsonb, timestamp with time zone) CASCADE;
+  SQL
+end

data/db/migrate/20250121012334_enable_hstore.rb

@@ -0,0 +1,5 @@
+class EnableHstore < ActiveRecord::Migration[8.0]
+  def change
+    enable_extension :hstore
+  end
+end

data/lib/panda/core/configuration.rb

@@ -2,6 +2,7 @@ module Panda
   module Core
     class Configuration
       attr_accessor :user_class,
+        :user_identity_class,
         :storage_provider,
         :cache_store,
         :parent_controller,
@@ -11,13 +12,15 @@ module Panda
         :session_token_cookie
 
       def initialize
+        @user_class = "Panda::Core::User"
+        @user_identity_class = "Panda::Core::UserIdentity"
         @storage_provider = :active_storage
         @cache_store = :memory_store
         @parent_controller = "ActionController::API"
         @parent_mailer = "ActionMailer::Base"
         @mailer_sender = "support@example.com"
         @mailer_default_url_options = {host: "localhost:3000"}
-        @session_token_cookie = :session_token
+        @session_token_cookie = :panda_session
       end
     end
 

data/lib/panda/core/engine.rb

@@ -7,10 +7,13 @@ require "dry-configurable"
 require "faraday"
 require "faraday/multipart"
 require "faraday/retry"
+require "fx"
 require "image_processing"
 require "importmap-rails"
+require "logidze"
 require "lookbook"
 require "omniauth"
+require "omniauth/rails_csrf_protection"
 require "propshaft"
 require "redis"
 require "silencer"

data/lib/panda/core/railtie.rb

@@ -2,5 +2,7 @@ require "rails/railtie"
 
 module Panda
   module Core
+    class Railtie < Rails::Railtie
+    end
   end
 end

data/lib/panda/core/version.rb

@@ -2,6 +2,6 @@
 
 module Panda
   module Core
-    VERSION = "0.1.11"
+    VERSION = "0.1.12"
   end
 end