CREATE TABLE IF NOT EXISTS post (
   id serial primary key,
   title text not null
);


INSERT INTO post(title) VALUES ('Post 1'), ('Post 2');

SELECT p.*
FROM post p;

CREATE TYPE group_condition AS enum ('OR', 'AND');

CREATE TABLE IF NOT EXISTS policy (
    id serial primary key,
    name varchar,
    resolver_code  varchar(255) not null
);

CREATE TABLE IF NOT EXISTS claim (
    id serial primary key,
    code varchar,
    name varchar,
    replaceable_by_user boolean default true
);

CREATE TABLE IF NOT EXISTS policy_claim (
    policy_id integer not null
        references policy on delete restrict,
    claim_id integer not null references claim on delete restrict,
    where_condition text default '%1$s = %2$s'::text not null,
    primary key (policy_id, claim_id)
);


CREATE TABLE IF NOT EXISTS post_group_policy (
    id serial primary key,
    type group_condition       not null,
    parent_group integer
        constraint post_group_policy_post_group_policy_id_fk
            references post_group_policy
            on delete cascade,
    negative boolean default false not null
);

CREATE TABLE IF NOT EXISTS post_ability (
    code varchar not null primary key,
    name varchar not null
);

CREATE TABLE IF NOT EXISTS post_policy (
    id serial primary key,
    entity_id int not null constraint post_policy_post_id_fk
            references post on delete cascade,
    policy_id integer not null references policy on delete restrict,
    group_id integer references post_group_policy on delete cascade,
    ability varchar not null references post_ability on delete restrict,
    negative  boolean default false not null
);

CREATE TABLE IF NOT EXISTS post_policy_claim (
    entity_policy_id integer not null
        constraint post_policy_claim_post_policy_id_fkey
            references post_policy
            on delete cascade,
    claim_id integer not null
        references claim
            on delete restrict,
    value varchar not null,
    primary key (entity_policy_id, claim_id, value)
);

CREATE TABLE IF NOT EXISTS post_indexed_rule (
    entity_id int not null,
    condition text not null,
    ability varchar not null references post_ability on delete cascade,
    used_claims character varying[] not null,
    constraint post_indexed_rule_pk
        primary key (ability, entity_id)
);

/**
  Функция чтобы перевернуть условие, если нужно
 */
DROP FUNCTION IF EXISTS __process_policy_negative;
CREATE FUNCTION __process_policy_negative(_condition text, _is_negative boolean)
    RETURNS text
AS $$
DECLARE
    _format text;
BEGIN
    IF _is_negative THEN
        _format = 'NOT(%s)';
    ELSE
        _format = '%s';
    END IF;
    RETURN format(_format, _condition);
END
$$ LANGUAGE plpgsql;

/**
  Обработка условий для группы
  Функция рекурсивная. Ей на вход приходит корневая группа, и вызывается вниз по дереву для каждой группы
 */
DROP FUNCTION IF EXISTS __process_policy_group_condition;
CREATE FUNCTION __process_policy_group_condition(_entity_policy_group record, _query text)
    RETURNS text
AS $$
DECLARE
    _group_policies record;
    _format text;
BEGIN
    -- склейм условия группы с родительской группой (или ни с чем если ф-ия вызывается первый раз)
    _query = format('%s%s', _query, _entity_policy_group.group_condition);

    -- найдём все дочерние группы текущей группы
    BEGIN FOR _group_policies IN
        SELECT *
        FROM policy_group_condition p
        WHERE p.parent_group = _entity_policy_group.group_id
        LOOP

            -- если группа с отрицанием, то нужно перевернуть условие дочерней группы
            IF _entity_policy_group.negative THEN
                _format = '%s %s NOT(';
            ELSE
                _format = '%s %s (';
            end if;
            _query := format(_format, _query, _entity_policy_group.type);
            -- обработаем дочернюю группу рекурсивно
            SELECT __process_policy_group_condition(_group_policies, _query) INTO _query;
            _query := _query || ')';
        END LOOP;
    END;
    return _query;
END;
$$ LANGUAGE plpgsql;

DROP FUNCTION IF EXISTS __process_user_claim_value;
CREATE FUNCTION __process_user_claim_value(_user_claim_value_jsonb jsonb)
    RETURNS text
AS $$
DECLARE
    _user_claim_value text;
    _user_claim_value_type text;
    _user_claim_value_array_item_jsonb jsonb;
    _user_claim_value_array_item_type text;
    _user_claim_value_array_int_result int[] DEFAULT ARRAY[]::int[];
    _user_claim_value_array_text_result text[] DEFAULT ARRAY[]::text[];
BEGIN
    -- текстовое значение кляйма
    _user_claim_value := _user_claim_value_jsonb ->> 0;

    -- если пользователь не передал кляйм, значит будем проверять на пустоту (т.е. политика должна требовать пустой кляйм)
    IF _user_claim_value IS NULL THEN
        _user_claim_value = format('%L', '');
    ELSE
        -- получаем тип переданого кляйма
        _user_claim_value_type = jsonb_typeof(_user_claim_value_jsonb);
        CASE

            -- если это массив
            WHEN _user_claim_value_type = 'array' THEN

                -- если не пустой, тогда превратим jsonb массив в строку, соединенную запятымы ([1,2,3,4] => '1,2,3,4')
                IF jsonb_array_length(_user_claim_value_jsonb) > 0 THEN
                    _user_claim_value := format('%L', '');

                    -- тут надо правильно преобразовать jsonb массив в строку для поиска.
                    -- с интами все просто [1,2,3] => 1,2,3
                    -- а стринги нужно из ["s1", "s2"] преобразовать в 's1','s2' (поменять кавычки)
                    -- для этого мы ходим по каждому элементу массива
                    -- тут мы используем 2 массива: числовой (_user_claim_value_array_int_result) и текстовой (_user_claim_value_array_text_result)
                    -- в зависимости от типа значения, мы помещаем его в нужный массив
                    -- потом мы массив, в котором есть значения, конкатим по запятой и присваиваем результату
                    FOR _user_claim_value_array_item_jsonb IN SELECT a FROM jsonb_array_elements(_user_claim_value_jsonb) as a
                        LOOP
                            -- берем его тип
                            _user_claim_value_array_item_type = jsonb_typeof(_user_claim_value_array_item_jsonb );
                            CASE
                                -- если это инт, то пихаем как есть в числовой массив
                                WHEN _user_claim_value_array_item_type = 'number' THEN
                                    SELECT array_append(_user_claim_value_array_int_result, _user_claim_value_array_item_jsonb::int) INTO _user_claim_value_array_int_result;

                                -- если это строка, то экстрактим её значение и пихаем в текстовый массив
                                WHEN _user_claim_value_array_item_type = 'string' THEN
                                    SELECT array_append(_user_claim_value_array_text_result, format('%L', _user_claim_value_array_item_jsonb ->> 0)) INTO _user_claim_value_array_text_result;
                                END CASE;
                        END LOOP;

                    -- если есть значения в текстовом массиве
                    IF array_length(_user_claim_value_array_text_result, 1) > 0 THEN
                        SELECT INTO _user_claim_value array_to_string(_user_claim_value_array_text_result, ',');

                        -- если есть значения в числовом массиве
                    ELSIF array_length(_user_claim_value_array_int_result, 1) > 0 THEN
                        SELECT INTO _user_claim_value array_to_string(_user_claim_value_array_int_result, ',');
                    END IF;

                ELSE
                    _user_claim_value = 'NULL';
                END IF;
            ELSE

                -- если это скалярное выражение, то просто обернем его в кавычки
                _user_claim_value = format('%L', _user_claim_value);
            END CASE;
    END IF;

    RETURN _user_claim_value;
END;
$$ LANGUAGE plpgsql;


DROP FUNCTION IF EXISTS index_entity_policies;
CREATE FUNCTION index_entity_policies(_table_prefix varchar, _entity_id anyelement, _ability anycompatible)
    RETURNS void
AS $$
DECLARE
    _policy_group_condition record;
    _check_query text;
    _check_where text default '';
    _used_claims varchar[] default ARRAY[]::varchar[];
BEGIN
    -- сохраним во временную таблицу все сохраненные политики для этой сущности
    CREATE TEMPORARY TABLE IF NOT EXISTS entity_policies (
                                                             id int,
                                                             policy_id int,
                                                             group_id int,
                                                             negative boolean
    );

    TRUNCATE TABLE entity_policies;
    EXECUTE format('INSERT INTO entity_policies ' ||
                   'SELECT id, policy_id, group_id, negative FROM %I WHERE entity_id = $1 AND ability = $2;', _table_prefix || '_policy')
        USING  _entity_id, _ability;

    -- если нет политик или возможностей
    IF NOT EXISTS(SELECT 1 from entity_policies) THEN
        RETURN;
    END IF;

    -- сохраним во временную таблицу все кляймы, которые требуются. подцепим к ним информацию о группе, в которой находятся политики
    CREATE TEMPORARY TABLE IF NOT EXISTS required_policy_claims(
                                                                   id int,
                                                                   policy_id int,
                                                                   claim_id int,
                                                                   code text,
                                                                   value text,
                                                                   where_condition text,
                                                                   group_id int,
                                                                   parent_group int,
                                                                   type group_condition,
                                                                   negative boolean,
                                                                   entity_policy_negative boolean,
                                                                   replaceable_by_user_claim boolean
    );
    TRUNCATE TABLE required_policy_claims;
    EXECUTE format(
                                    'INSERT INTO required_policy_claims ' ||
                                    'SELECT ep.id, ep.policy_id, stpc.claim_id, c.code, stpc.value, pc.where_condition, ep.group_id, stgp.parent_group, stgp.type, stgp.negative, ep.negative as entity_policy_negative, c.replaceable_by_user replaceable_by_user_claim ' ||
                                    'FROM %I stpc ' ||
                                    'INNER JOIN entity_policies ep on stpc.entity_policy_id = ep.id ' ||
                                    'INNER JOIN claim c on c.id = stpc.claim_id ' ||
                                    'INNER JOIN %I stgp on stgp.id = ep.group_id ' ||
                                    'INNER JOIN policy_claim pc on ep.policy_id = pc.policy_id AND stpc.claim_id = pc.claim_id',
                                    _table_prefix || '_policy_claim', _table_prefix || '_group_policy'
        );

    -- в эту временную таблицу мы складываем уже сгруппированные политики по группам
    CREATE TEMPORARY TABLE IF NOT EXISTS policy_group_condition (
                                                                    group_id int,
                                                                    parent_group int,
                                                                    group_condition text,
                                                                    type text,
                                                                    negative boolean
    );
    TRUNCATE TABLE policy_group_condition;
    INSERT INTO policy_group_condition
    WITH policits_with_cond AS (
        SELECT rpc.id,
               -- тут мы объединяем кляймы одной политики по условию AND
               format('(%s)', array_to_string(array_agg(format(__process_policy_negative(rpc.where_condition, rpc.entity_policy_negative), quote_literal(rpc.value), format('[#%s#]', rpc.code))), ') AND (')) as condition,
               rpc.group_id,
               rpc.parent_group,
               rpc.type,
               rpc.negative
        FROM required_policy_claims rpc
        GROUP BY rpc.id, rpc.type, rpc.group_id, rpc.parent_group, rpc.type, rpc.negative
        ORDER BY rpc.id
    ), policits_by_groups AS (
        SELECT
            p.group_id,
            p.parent_group,
            -- объединяем политики в группе по условию, прописанному в группе
            format('(%s)', array_to_string(array_agg(__process_policy_negative(p.condition, p.negative)), format(') %s (', p.type))) as group_condition,
            p.type,
            p.negative
        FROM policits_with_cond p
        GROUP BY p.group_id, p.type, p.parent_group, p.negative
        ORDER BY p.group_id
    ) SELECT * FROM policits_by_groups;

    -- начем рекурсивно проходить по группам. начинаем с корневой группы
    BEGIN FOR _policy_group_condition IN
        SELECT * FROM policy_group_condition p WHERE p.parent_group IS NULL
        LOOP
            SELECT __process_policy_group_condition(_policy_group_condition, _check_where) INTO _check_where;
        END LOOP;
    END;

    SELECT INTO _used_claims ARRAY(SELECT DISTINCT code FROM required_policy_claims WHERE replaceable_by_user_claim = true);

    -- иготовый запрос, который будем проверять.
    _check_query := format('SELECT true WHERE (%s)', _check_where);

    EXECUTE format('INSERT INTO %I(entity_id, ability, condition, used_claims) ' ||
                   'VALUES ($1, $2, $3, $4) ' ||
                   'ON CONFLICT (entity_id, ability) DO UPDATE ' ||
                   'SET condition = $3, used_claims = $4', _table_prefix || '_indexed_rule')
        USING _entity_id, _ability, _check_where, _used_claims;


END
$$ LANGUAGE plpgsql;

DROP FUNCTION IF EXISTS check_user_rights;
CREATE FUNCTION check_user_rights(_table_prefix varchar, _entity_id anyelement, _ability anycompatible, _user_claims jsonb)
    RETURNS boolean
AS $$
DECLARE
    _where_condition record;
    _used_claim varchar;
    _result_condition text;
    _check_query boolean;
BEGIN

    EXECUTE format('SELECT condition, used_claims ' ||
                   'FROM %I WHERE entity_id = $1 AND ability = $2;', _table_prefix || '_indexed_rule')
        USING _entity_id, _ability INTO _where_condition ;

    _result_condition = _where_condition.condition;

    IF _where_condition IS NULL THEN
        RETURN NULL;
    END IF;

    FOREACH _used_claim IN ARRAY _where_condition.used_claims
        LOOP
            SELECT INTO _result_condition replace(_result_condition, format('[#%s#]', _used_claim), COALESCE(_user_claims ->> _used_claim, quote_literal('')));
        END LOOP;

    EXECUTE format('SELECT true WHERE (%s)', _result_condition) INTO _check_query;
    RETURN _check_query;
END
$$ LANGUAGE plpgsql;


DROP FUNCTION IF EXISTS __process_user_claim_values;
CREATE FUNCTION __process_user_claim_values(_user_claims jsonb)
    RETURNS jsonb
AS $$
DECLARE
    _json_el record;
    _jsonb_result jsonb default '{}'::jsonb;
BEGIN
    BEGIN FOR _json_el IN
        select key, value from jsonb_each(_user_claims)
        LOOP
            SELECT INTO _jsonb_result jsonb_set(_jsonb_result, ARRAY[_json_el.key], to_jsonb(__process_user_claim_value(_json_el.value)));
        END LOOP;
    END;
    RETURN _jsonb_result;
END;
$$ LANGUAGE plpgsql;

DROP FUNCTION IF EXISTS check_index_rules CASCADE;
CREATE FUNCTION check_index_rules() RETURNS trigger AS $$
DECLARE
    _rows_count int;
BEGIN
    EXECUTE format('SELECT count(*) FROM %I ' ||
                   'WHERE entity_id = $1 AND ability = $2', TG_ARGV[0] || '_policy')
        USING old.entity_id, old.ability INTO _rows_count ;

    IF _rows_count = 0 THEN
        EXECUTE format('DELETE FROM %I WHERE entity_id = $1 AND ability = $2', TG_ARGV[0] || '_indexed_rule')
            USING old.entity_id, old.ability;

    END IF;
    RETURN new;
END;
$$ LANGUAGE plpgsql;

-- тригер, который следит за правилами. Если будет удалено последнее правило, то удалится и проиндексированное правило
CREATE TRIGGER post_clear_index AFTER DELETE ON post_policy
	FOR EACH ROW EXECUTE FUNCTION check_index_rules('post');

SELECT p.*
FROM
   post p,
   LATERAL (SELECT /* (1) */ __process_user_claim_values(/* (2) */ '{"age": 24, "location": "Москва", "userId": 123}'::jsonb) as processed_user_claim) l
WHERE check_user_rights(
   'post', /* (3) */
   p.id, /* (4) */
   'edit', /* (5) */
   l.processed_user_claim /* (6) */
);

SELECT __process_user_claim_values('{
   "intValue": 12345,
   "stringValue": "abcde",
   "stringArrayValue": ["a", "b", "c"],
   "intArrayValue": [1,2,3,4,5]
}'::jsonb);

Результатом будет немного измененный jsonb.

{
   "intValue": "'12345'",
   "stringValue": "'abcde'",
   "intArrayValue": "1,2,3,4,5",
   "stringArrayValue": "'a','b','c'"
}

• intValue, stringValue - значения обернулись в кавычки.

• intArrayValue - массив преобразовался в строку, где значения разделены запятой. 

• stringArrayValue - массив также преобразовался в строку, где значения разделены запятой, но каждое значение обернуто в кавычки.

Теперь эти значения можно вставлять в WHERE выражения. Например, intArrayValue и stringArrayValue можно использовать в выражении IN. 

SELECT … FROM … WHERE p.id IN (1,2,3,4,5).

• Добавим политики

INSERT INTO policy (name, resolver_code)
VALUES ('Возраст старше', 'age_older'), 
       ('Город проживания', 'location'), 
       ('ID пользователя', 'user_id');

• Добавим клэймы.

INSERT INTO claim (code, name)
VALUES ('age', 'Возраст'), 
       ('location', 'Город проживания'), 
       ('user_id', 'ID пользователя');


INSERT INTO policy_claim (policy_id, claim_id, where_condition)
VALUES (2, 2, '%1$s::int <= %2$s::int'), 
       (3, 3, '%1$s = %2$s'), 
       (4, 4, '%1$s = %2$s');

• Добавим правила.

-- добавление групп
INSERT INTO post_group_policy (type, parent_group) VALUES ('AND', 1); -- Добавлена группа первого уровня с ID: 2
INSERT INTO post_group_policy (type, parent_group) VALUES ('OR', 2); -- Добавлена группа второго уровня с ID: 3


-- добавление правила
INSERT INTO post_policy (entity_id, policy_id, group_id, ability)
VALUES (1 /* ID поста */, 1 /* Политика "Состоит в группе" */, 2 /* группа первого уровня */ , 'edit'); -- Добавлено правило с ID: 2


INSERT INTO post_policy_claim (entity_policy_id, claim_id, value)
VALUES (2 /* правило, добавленное в пред. запросе */, 1 /* клэйм "Состоит в группе" */, 2 /* ID группы */);


INSERT INTO post_policy (entity_id, policy_id, group_id, ability)
VALUES (1 /* ID поста */, 2 /* Политика "Возраст старше" */, 2 /* группа первого уровня */, 'edit'); -- Добавлено правило с ID: 3


INSERT INTO post_policy_claim (entity_policy_id, claim_id, value)
VALUES (3 /* правило, добавленное в пред. запросе */, 2 /* клэйм "Возраст" */, 18 /* Возраст */);


INSERT INTO post_policy (entity_id, policy_id, group_id, ability)
VALUES (1 /* ID поста */, 3 /* политика "Город проживания" */, 3 /* группа второго уровня */, 'edit'); -- Добавлено правило с ID: 4


INSERT INTO post_policy_claim (entity_policy_id, claim_id, value)
VALUES (4 /* правило, добавленное в пред. запросе */, 3 /* клэйм "Город проживания" */, 'Москва');


INSERT INTO post_policy (entity_id, policy_id, group_id, ability)
VALUES (1 /* ID поста */, 3 /* политика "Город проживания" */, 3 /* группа второго уровня */, 'edit'); -- Добавлено правило с ID: 5


INSERT INTO post_policy_claim (entity_policy_id, claim_id, value)
VALUES (5 /* правило, добавленное в пред. запросе */, 3 /* клэйм "Город проживания" */, 'Санкт-Петербург');


INSERT INTO post_policy (entity_id, policy_id, group_id, ability)
VALUES (1 /* ID поста */, 4 /* политика "ID пользователя" */, 1 /* корневая группа */, 'edit'); -- Добавлено правило с ID: 6


INSERT INTO post_policy_claim (entity_policy_id, claim_id, value)
VALUES (6 /* правило, добавленное в пред. запросе */, 4 /* клэйм "ID пользователя" */, 123);


-- проиндексируем изменения
SELECT index_entity_policies('post', 1, 'edit');

Получилось такое WHERE выражение

(
  ('1'::int in ([#group#]))
) OR (
  ('123' = [#user_id#])
) OR (
  (
    ('2'::int in ([#group#]))
  ) AND (
    ('18'::int < [#age#]::int)
  ) AND (
    (
      ('Москва' = [#location#])
    ) OR (
      ('Санкт-Петербург' = [#location#])
    )
  )
).

Пользователь состоит в группе 2, 17 лет, живет в Москве. ID = 124

SELECT p.id, p.*
FROM
  post p,
  LATERAL (SELECT __process_user_claim_values('{"group": [2], "age": 17, "location": "Москва", "user_id": 124}'::jsonb) as processed_user_claim) l
WHERE check_user_rights(
          'post',
          p.id,
          'edit',
          l.processed_user_claim
       );

Ничего нет. Клэймы не удовлетворяют условию.

Пользователь состоит в группе 2, 25 лет, живет в Москве. ID = 124

SELECT p.id, p.*
FROM
  post p,
  LATERAL (SELECT __process_user_claim_values('{"group": [2], "age": 25, "location": "Москва", "user_id": 124}'::jsonb) as processed_user_claim) l
WHERE check_user_rights(
          'post',
          p.id,
          'edit',
          l.processed_user_claim
       );

Пользователь состоит в группе 2, 17 лет, живет в Москве. ID = 123

SELECT p.id, p.*
FROM
  post p,
  LATERAL (SELECT __process_user_claim_values('{"group": [2], "age": 17, "location": "Москва", "user_id": 123}'::jsonb) as processed_user_claim) l
WHERE check_user_rights(
          'post',
          p.id,
          'edit',
          l.processed_user_claim
       );

Пользователю 17 лет и проверку 2 он уже не пройдет, зато проходит проверку политики ID Пользователя = 123

Пользователь состоит в группе 1 и 2, 17 лет, живет в Москве. ID = 124

SELECT p.id, p.*
FROM
  post p,
  LATERAL (SELECT __process_user_claim_values('{"group": [1, 2], "age": 17, "location": "Москва", "user_id": 124}'::jsonb) as processed_user_claim) l
WHERE check_user_rights(
          'post',
          p.id,
          'edit',
          l.processed_user_claim
       );

Проверки 2 и 3 уже не пройдут, зато эти клэймы удовлетворяют политике Состоит в группе = 1