@pgpm/achievements 0.4.0

package/__tests__/triggers.test.ts

@@ -0,0 +1,167 @@
+import { getConnections, PgTestClient } from 'pgsql-test';
+import { snapshot } from 'graphile-test';
+
+let pg: PgTestClient;
+let teardown:  () => Promise<void>;
+
+const user_id = 'b9d22af1-62c7-43a5-b8c4-50630bbd4962';
+
+const levels = ['newbie', 'advanced'];
+
+const newbie = [
+  ['upload_profile_image'],
+  ['complete_action', 5],
+  ['accept_cookies'],
+  ['accept_privacy'],
+  ['agree_to_terms']
+];
+const advanced = [
+  ['invite_users', 15],
+  ['complete_action', 15]
+];
+
+beforeAll(async () => {
+  ({ pg, teardown } = await getConnections());
+
+  await pg.any(`CREATE TABLE status_public.mytable (
+    id serial,
+    name text,
+    toggle text,
+    is_approved boolean,
+    is_verified boolean default false
+  );`);
+
+  await pg.any(`CREATE TRIGGER mytable_tg1 
+    BEFORE INSERT ON status_public.mytable 
+    FOR EACH ROW
+    EXECUTE FUNCTION status_private.tg_achievement('name', 'tg_achievement');`);
+
+  await pg.any(`CREATE TRIGGER mytable_tg2
+    BEFORE UPDATE ON status_public.mytable 
+    FOR EACH ROW
+    WHEN (NEW.name IS DISTINCT FROM OLD.name)
+    EXECUTE FUNCTION status_private.tg_achievement('name', 'tg_achievement');`);
+
+  await pg.any(`CREATE TRIGGER mytable_tg3
+    BEFORE INSERT ON status_public.mytable
+    FOR EACH ROW
+    EXECUTE FUNCTION status_private.tg_achievement_toggle('toggle', 'tg_achievement_toggle');`);
+
+  await pg.any(`CREATE TRIGGER mytable_tg4
+    BEFORE UPDATE ON status_public.mytable
+    FOR EACH ROW
+    WHEN (NEW.toggle IS DISTINCT FROM OLD.toggle)
+    EXECUTE FUNCTION status_private.tg_achievement_toggle('toggle', 'tg_achievement_toggle');`);
+
+  await pg.any(`CREATE TRIGGER mytable_tg5
+    BEFORE INSERT ON status_public.mytable
+    FOR EACH ROW
+    EXECUTE FUNCTION status_private.tg_achievement_boolean('is_approved', 'tg_achievement_boolean');`);
+
+  await pg.any(`CREATE TRIGGER mytable_tg6
+    BEFORE UPDATE ON status_public.mytable
+    FOR EACH ROW
+    WHEN (NEW.is_approved IS DISTINCT FROM OLD.is_approved)
+    EXECUTE FUNCTION status_private.tg_achievement_boolean('is_approved', 'tg_achievement_boolean');`);
+
+  await pg.any(`CREATE TRIGGER mytable_tg7
+    BEFORE INSERT ON status_public.mytable
+    FOR EACH ROW
+    EXECUTE FUNCTION status_private.tg_achievement_toggle_boolean('is_verified', 'tg_achievement_toggle_boolean');`);
+
+  await pg.any(`CREATE TRIGGER mytable_tg8
+    BEFORE UPDATE ON status_public.mytable
+    FOR EACH ROW
+    WHEN (NEW.is_verified IS DISTINCT FROM OLD.is_verified)
+    EXECUTE FUNCTION status_private.tg_achievement_toggle_boolean('is_verified', 'tg_achievement_toggle_boolean');`);
+
+  await pg.setContext({
+    'jwt.claims.user_id': user_id
+  });
+});
+
+afterAll(async () => {
+  await teardown();
+});
+
+beforeEach(async () => {
+  await pg.beforeEach();
+
+  for (const name of levels) {
+    await pg.any(
+      `INSERT INTO status_public.levels (name) VALUES ($1) ON CONFLICT DO NOTHING`,
+      [name]
+    );
+  }
+
+  for (const [name, required_count = 1] of newbie) {
+    await pg.any(
+      `INSERT INTO status_public.level_requirements (name, level, required_count)
+       VALUES ($1, $2, $3) ON CONFLICT DO NOTHING`,
+      [name, 'newbie', required_count]
+    );
+  }
+  for (const [name, required_count = 1] of advanced) {
+    await pg.any(
+      `INSERT INTO status_public.level_requirements (name, level, required_count)
+       VALUES ($1, $2, $3) ON CONFLICT DO NOTHING`,
+      [name, 'advanced', required_count]
+    );
+  }
+});
+
+afterEach(async () => {
+  await pg.afterEach();
+});
+
+it('newbie', async () => {
+  const beforeInsert = await pg.any(
+    `SELECT * FROM status_public.user_achievements ORDER BY name`
+  );
+  expect(snapshot({ beforeInsert })).toMatchSnapshot();
+
+  await pg.any(
+    `INSERT INTO status_public.mytable (name) VALUES ($1)`,
+    ['upload_profile_image']
+  );
+
+  const afterFirstInsert = await pg.any(
+    `SELECT * FROM status_public.user_achievements ORDER BY name`
+  );
+  expect(snapshot({ afterFirstInsert })).toMatchSnapshot();
+
+  await pg.any(`UPDATE status_public.mytable SET toggle = 'yo'`);
+
+  const afterUpdateToggleToValue = await pg.any(
+    `SELECT * FROM status_public.user_achievements ORDER BY name`
+  );
+  expect(snapshot({ afterUpdateToggleToValue })).toMatchSnapshot();
+
+  await pg.any(`UPDATE status_public.mytable SET toggle = NULL`);
+
+  const afterUpdateToggleToNull = await pg.any(
+    `SELECT * FROM status_public.user_achievements ORDER BY name`
+  );
+  expect(snapshot({ afterUpdateToggleToNull })).toMatchSnapshot();
+
+  await pg.any(`UPDATE status_public.mytable SET is_verified = TRUE`);
+
+  const afterIsVerifiedIsTrue = await pg.any(
+    `SELECT * FROM status_public.user_achievements ORDER BY name`
+  );
+  expect(snapshot({ afterIsVerifiedIsTrue })).toMatchSnapshot();
+
+  await pg.any(`UPDATE status_public.mytable SET is_verified = FALSE`);
+
+  const afterIsVerifiedIsFalse = await pg.any(
+    `SELECT * FROM status_public.user_achievements ORDER BY name`
+  );
+  expect(snapshot({ afterIsVerifiedIsFalse })).toMatchSnapshot();
+
+  await pg.any(`UPDATE status_public.mytable SET is_approved = TRUE`);
+
+  const afterIsApprovedTrue = await pg.any(
+    `SELECT * FROM status_public.user_achievements ORDER BY name`
+  );
+  expect(snapshot({ afterIsApprovedTrue })).toMatchSnapshot();
+});

package/deploy/schemas/status_private/procedures/status_triggers.sql

@@ -0,0 +1,148 @@
+-- Deploy schemas/status_private/procedures/status_triggers to pg
+
+-- requires: schemas/status_private/schema
+-- requires: schemas/status_private/procedures/user_completed_step 
+-- requires: schemas/status_private/procedures/user_incompleted_step 
+
+BEGIN;
+
+CREATE FUNCTION status_private.tg_achievement ()
+  RETURNS TRIGGER
+  AS $$
+DECLARE
+  is_null boolean;
+  task_name text;
+BEGIN
+    IF (TG_OP = 'INSERT' OR TG_OP = 'UPDATE') THEN
+        task_name = TG_ARGV[1]::text;
+        EXECUTE format('SELECT ($1).%s IS NULL', TG_ARGV[0])
+        USING NEW INTO is_null;
+        IF (is_null IS FALSE) THEN
+            PERFORM status_private.user_completed_step(task_name);
+        END IF;
+        RETURN NEW;
+    END IF;
+END;
+$$
+LANGUAGE 'plpgsql'
+VOLATILE;
+
+CREATE FUNCTION status_private.tg_achievement_toggle ()
+  RETURNS TRIGGER
+  AS $$
+DECLARE
+  is_null boolean;
+  task_name text;
+BEGIN
+    IF (TG_OP = 'INSERT' OR TG_OP = 'UPDATE') THEN
+        task_name = TG_ARGV[1]::text;
+        EXECUTE format('SELECT ($1).%s IS NULL', TG_ARGV[0])
+        USING NEW INTO is_null;
+        IF (is_null IS TRUE) THEN
+            PERFORM status_private.user_incompleted_step(task_name);
+        ELSE
+            PERFORM status_private.user_completed_step(task_name);
+        END IF;
+        RETURN NEW;
+    END IF;
+END;
+$$
+LANGUAGE 'plpgsql'
+VOLATILE;
+
+CREATE FUNCTION status_private.tg_achievement_boolean ()
+  RETURNS TRIGGER
+  AS $$
+DECLARE
+  is_true boolean;
+  task_name text;
+BEGIN
+    IF (TG_OP = 'INSERT' OR TG_OP = 'UPDATE') THEN
+        task_name = TG_ARGV[1]::text;
+        EXECUTE format('SELECT ($1).%s IS TRUE', TG_ARGV[0])
+        USING NEW INTO is_true;
+        IF (is_true IS TRUE) THEN
+            PERFORM status_private.user_completed_step(task_name);
+        END IF;
+        RETURN NEW;
+    END IF;
+END;
+$$
+LANGUAGE 'plpgsql'
+VOLATILE;
+
+CREATE FUNCTION status_private.tg_achievement_toggle_boolean ()
+  RETURNS TRIGGER
+  AS $$
+DECLARE
+  is_true boolean;
+  task_name text;
+BEGIN
+    IF (TG_OP = 'INSERT' OR TG_OP = 'UPDATE') THEN
+        task_name = TG_ARGV[1]::text;
+        EXECUTE format('SELECT ($1).%s IS TRUE', TG_ARGV[0])
+        USING NEW INTO is_true;
+        IF (is_true IS TRUE) THEN
+            PERFORM status_private.user_completed_step(task_name);
+        ELSE
+            PERFORM status_private.user_incompleted_step(task_name);
+        END IF;
+        RETURN NEW;
+    END IF;
+END;
+$$
+LANGUAGE 'plpgsql'
+VOLATILE;
+
+-- CREATE FUNCTION app_private.tg_achievement_using_field ()
+--   RETURNS TRIGGER
+--   AS $$
+-- DECLARE
+--   is_null boolean;
+--   task_name citext;
+--   user_id uuid;
+-- BEGIN
+--     IF (TG_OP = 'INSERT' OR TG_OP = 'UPDATE') THEN
+--         task_name = TG_ARGV[1]::citext;
+--         EXECUTE format('SELECT ($1).%s IS NULL', TG_ARGV[0])
+--         USING NEW INTO is_null;
+--         EXECUTE format('SELECT ($1).%s::uuid', TG_ARGV[2])
+--         USING NEW INTO user_id;
+--         IF (is_null IS FALSE) THEN
+--             PERFORM app_private.user_completed_task(task_name, user_id);
+--         END IF;
+--         RETURN NEW;
+--     END IF;
+-- END;
+-- $$
+-- LANGUAGE 'plpgsql'
+-- VOLATILE;
+
+-- CREATE FUNCTION app_private.tg_achievement_toggle_using_field ()
+--   RETURNS TRIGGER
+--   AS $$
+-- DECLARE
+--   is_null boolean;
+--   task_name citext;
+--   user_id uuid;
+-- BEGIN
+--     IF (TG_OP = 'INSERT' OR TG_OP = 'UPDATE') THEN
+--         task_name = TG_ARGV[1]::citext;
+--         EXECUTE format('SELECT ($1).%s IS NULL', TG_ARGV[0])
+--         USING NEW INTO is_null;
+--         EXECUTE format('SELECT ($1).%s::uuid', TG_ARGV[2])
+--         USING NEW INTO user_id;
+--         IF (is_null IS TRUE) THEN
+--             PERFORM app_private.user_incompleted_task(task_name, user_id);
+--         ELSE
+--             PERFORM app_private.user_completed_task(task_name, user_id);
+--         END IF;
+--         RETURN NEW;
+--     END IF;
+-- END;
+-- $$
+-- LANGUAGE 'plpgsql'
+-- VOLATILE;
+
+
+COMMIT;

package/deploy/schemas/status_private/procedures/upsert_achievement.sql

@@ -0,0 +1,24 @@
+-- Deploy schemas/status_private/procedures/upsert_achievement to pg
+
+-- requires: schemas/status_private/schema
+-- requires: schemas/status_public/tables/user_achievements/table 
+
+BEGIN;
+
+CREATE FUNCTION status_private.upsert_achievement(
+  vuser_id uuid, vname text, vcount int
+) returns void as $$
+BEGIN
+    INSERT INTO status_public.user_achievements (user_id, name, count)
+    VALUES 
+        (vuser_id, vname, GREATEST(vcount, 0))
+    ON CONFLICT ON CONSTRAINT user_achievements_unique_key
+    DO UPDATE SET 
+        -- look ma! you can actually do aliases inside on conflict
+        count = user_achievements.count + EXCLUDED.count
+    ;
+END;
+$$
+LANGUAGE 'plpgsql' VOLATILE;
+
+COMMIT;

package/deploy/schemas/status_private/procedures/user_completed_step.sql

@@ -0,0 +1,16 @@
+-- Deploy schemas/status_private/procedures/user_completed_step to pg
+
+-- requires: schemas/status_private/schema
+-- requires: schemas/status_public/tables/user_steps/table
+
+BEGIN;
+
+CREATE FUNCTION status_private.user_completed_step (
+  step text,
+  user_id uuid DEFAULT jwt_public.current_user_id()
+) RETURNS void AS $EOFCODE$
+  INSERT INTO status_public.user_steps ( name, user_id, count )
+  VALUES ( step, user_id, 1 );
+$EOFCODE$ LANGUAGE sql VOLATILE SECURITY DEFINER;
+
+COMMIT;

package/deploy/schemas/status_private/procedures/user_incompleted_step.sql

@@ -0,0 +1,22 @@
+-- Deploy schemas/status_private/procedures/user_incompleted_step to pg
+
+-- requires: schemas/status_private/schema
+-- requires: schemas/status_public/tables/user_steps/table
+
+BEGIN;
+
+CREATE FUNCTION status_private.user_incompleted_step ( 
+  step text,
+  user_id uuid DEFAULT jwt_public.current_user_id()
+) RETURNS void AS $EOFCODE$
+BEGIN
+  DELETE FROM status_public.user_steps s
+    WHERE s.user_id = user_incompleted_step.user_id
+    AND s.name = step;
+  DELETE FROM status_public.user_achievements a
+    WHERE a.user_id = user_incompleted_step.user_id
+    AND a.name = step;
+END;
+$EOFCODE$ LANGUAGE plpgsql VOLATILE SECURITY DEFINER;
+
+COMMIT;

package/deploy/schemas/status_private/schema.sql

@@ -0,0 +1,15 @@
+-- Deploy schemas/status_private/schema to pg
+
+
+BEGIN;
+
+CREATE SCHEMA IF NOT EXISTS status_private;
+
+GRANT USAGE ON SCHEMA status_private
+TO authenticated, anonymous;
+
+ALTER DEFAULT PRIVILEGES IN SCHEMA status_private
+GRANT EXECUTE ON FUNCTIONS
+TO authenticated;
+
+COMMIT;

package/deploy/schemas/status_public/procedures/steps_required.sql

@@ -0,0 +1,59 @@
+-- Deploy schemas/status_public/procedures/steps_required to pg
+
+-- requires: schemas/status_public/schema
+-- requires: schemas/status_public/tables/level_requirements/table 
+-- requires: schemas/status_public/tables/user_achievements/table 
+
+BEGIN;
+
+-- good for debugging...
+
+-- SELECT 
+--       level_requirements.name,
+--       level_requirements.level,
+      
+--       coalesce(user_achievements.count,0) as completed,
+--       level_requirements.required_count as required,
+--       -1*(coalesce(user_achievements.count,0)-level_requirements.required_count) as count
+      
+--     FROM
+--       status_public.level_requirements 
+--     FULL OUTER JOIN status_public.user_achievements ON (
+--       user_achievements.name = level_requirements.name
+--       AND user_achievements.user_id ='b9d22af1-62c7-43a5-b8c4-50630bbd4962'
+--     )	
+--     JOIN status_public.levels ON (level_requirements.level = levels.name)
+-- ;
+
+CREATE FUNCTION status_public.steps_required(
+  vlevel text,
+  vrole_id uuid DEFAULT jwt_public.current_user_id()
+)
+RETURNS SETOF status_public.level_requirements
+  AS $$
+BEGIN
+  RETURN QUERY
+  SELECT 
+      level_requirements.id,
+      level_requirements.name,
+      level_requirements.level,
+      -1*(coalesce(user_achievements.count,0)-level_requirements.required_count) as required_count,
+      level_requirements.priority
+    FROM
+      status_public.level_requirements 
+    FULL OUTER JOIN status_public.user_achievements ON (
+      user_achievements.name = level_requirements.name
+      AND user_achievements.user_id =vrole_id
+    )	
+    JOIN status_public.levels ON (level_requirements.level = levels.name)
+  WHERE
+    level_requirements.level = vlevel
+    AND -1*(coalesce(user_achievements.count,0)-level_requirements.required_count) > 0
+  ORDER BY priority ASC
+;
+END;
+$$
+LANGUAGE 'plpgsql'
+STABLE;
+COMMIT;
+

package/deploy/schemas/status_public/procedures/user_achieved.sql

@@ -0,0 +1,29 @@
+-- Deploy schemas/status_public/procedures/user_achieved to pg
+
+-- requires: schemas/status_public/schema
+-- requires: schemas/status_public/procedures/steps_required 
+-- requires: schemas/status_public/tables/level_requirements/table 
+-- requires: schemas/status_public/tables/user_achievements/table 
+
+BEGIN;
+
+CREATE FUNCTION status_public.user_achieved(
+  vlevel text,
+  vrole_id uuid DEFAULT jwt_public.current_user_id()
+) returns boolean as $$
+DECLARE
+  c int;
+BEGIN
+  SELECT COUNT(*) FROM
+    status_public.steps_required(
+      vlevel,
+      vrole_id
+    )
+  INTO c;
+
+  RETURN c <= 0;
+END;
+$$
+LANGUAGE 'plpgsql' STABLE;
+
+COMMIT;

package/deploy/schemas/status_public/schema.sql

@@ -0,0 +1,15 @@
+-- Deploy schemas/status_public/schema to pg
+
+
+BEGIN;
+
+CREATE SCHEMA IF NOT EXISTS status_public;
+
+GRANT USAGE ON SCHEMA status_public
+TO authenticated, anonymous;
+
+ALTER DEFAULT PRIVILEGES IN SCHEMA status_public
+GRANT EXECUTE ON FUNCTIONS
+TO authenticated;
+
+COMMIT;

package/deploy/schemas/status_public/tables/level_requirements/table.sql

@@ -0,0 +1,21 @@
+-- Deploy schemas/status_public/tables/level_requirements/table to pg
+
+-- requires: schemas/status_public/schema
+-- requires: schemas/status_public/tables/levels/table 
+
+BEGIN;
+
+CREATE TABLE status_public.level_requirements (
+  id uuid PRIMARY KEY DEFAULT uuid_generate_v4 (),
+  name text NOT NULL,
+  level text NOT NULL,
+  required_count int DEFAULT 1,
+  priority int DEFAULT 100,
+  unique(name, level)
+);
+
+COMMENT ON TABLE status_public.level_requirements IS 'Requirements to achieve a level';
+CREATE INDEX ON status_public.level_requirements (name, level, priority);
+GRANT SELECT ON TABLE status_public.levels TO authenticated;
+
+COMMIT;

package/deploy/schemas/status_public/tables/levels/table.sql

@@ -0,0 +1,15 @@
+-- Deploy schemas/status_public/tables/levels/table to pg
+
+-- requires: schemas/status_public/schema
+
+BEGIN;
+
+CREATE TABLE status_public.levels (
+  name text NOT NULL PRIMARY KEY
+);
+
+COMMENT ON TABLE status_public.levels IS 'Levels for achievement';
+
+GRANT SELECT ON TABLE status_public.levels TO public;
+
+COMMIT;

package/deploy/schemas/status_public/tables/user_achievements/policies/enable_row_level_security.sql

@@ -0,0 +1,11 @@
+-- Deploy schemas/status_public/tables/user_achievements/policies/enable_row_level_security to pg
+
+-- requires: schemas/status_public/schema
+-- requires: schemas/status_public/tables/user_achievements/table
+
+BEGIN;
+
+ALTER TABLE status_public.user_achievements
+    ENABLE ROW LEVEL SECURITY;
+
+COMMIT;

package/deploy/schemas/status_public/tables/user_achievements/policies/user_achievements_policy.sql

@@ -0,0 +1,38 @@
+-- Deploy schemas/status_public/tables/user_achievements/policies/user_achievements_policy to pg
+
+-- requires: schemas/status_public/schema
+-- requires: schemas/status_public/tables/user_achievements/table
+-- requires: schemas/status_public/tables/user_achievements/policies/enable_row_level_security
+
+BEGIN;
+
+CREATE POLICY can_select_user_achievements ON status_public.user_achievements
+  FOR SELECT
+  USING (
+    jwt_public.current_user_id() = user_id
+  );
+
+CREATE POLICY can_insert_user_achievements ON status_public.user_achievements
+  FOR INSERT
+  WITH CHECK (
+    FALSE
+  );
+
+CREATE POLICY can_update_user_achievements ON status_public.user_achievements
+  FOR UPDATE
+  USING (
+    FALSE
+  );
+
+CREATE POLICY can_delete_user_achievements ON status_public.user_achievements
+  FOR DELETE
+  USING (
+    FALSE
+  );
+
+GRANT INSERT ON TABLE status_public.user_achievements TO authenticated;
+GRANT SELECT ON TABLE status_public.user_achievements TO authenticated;
+GRANT UPDATE ON TABLE status_public.user_achievements TO authenticated;
+GRANT DELETE ON TABLE status_public.user_achievements TO authenticated;
+
+COMMIT;

package/deploy/schemas/status_public/tables/user_achievements/table.sql

@@ -0,0 +1,20 @@
+-- Deploy schemas/status_public/tables/user_achievements/table to pg
+
+-- requires: schemas/status_public/schema
+
+BEGIN;
+
+CREATE TABLE status_public.user_achievements (
+    id uuid PRIMARY KEY DEFAULT uuid_generate_v4 (),
+    user_id uuid NOT NULL,
+    name text NOT NULL, -- relates to level_requirements.name
+    count int NOT NULL DEFAULT 0,
+    created_at timestamptz NOT NULL DEFAULT current_timestamp,
+    constraint user_achievements_unique_key unique (user_id, name)
+);
+
+COMMENT ON TABLE status_public.user_achievements IS 'This table represents the users progress for particular level requirements, tallying the total count. This table is updated via triggers and should not be updated maually.';
+
+CREATE INDEX ON status_public.user_achievements (user_id, name);
+
+COMMIT;

package/deploy/schemas/status_public/tables/user_levels/table.sql

@@ -0,0 +1,20 @@
+-- Deploy schemas/status_public/tables/user_levels/table to pg
+
+-- requires: schemas/status_public/schema
+
+BEGIN;
+
+-- NOT using yet, so commented it out for simplicity
+
+-- CREATE TABLE status_public.user_levels (
+--     id uuid PRIMARY KEY DEFAULT uuid_generate_v4 (),
+--     user_id uuid NOT NULL,
+--     name text NOT NULL, -- references levels
+--     created_at timestamptz NOT NULL DEFAULT current_timestamp  
+-- );
+
+-- COMMENT ON TABLE status_public.user_levels IS 'Cache table of the achieved levels';
+
+-- CREATE INDEX ON status_public.user_levels (user_id, name);
+
+COMMIT;

package/deploy/schemas/status_public/tables/user_steps/table.sql

@@ -0,0 +1,18 @@
+-- Deploy schemas/status_public/tables/user_steps/table to pg
+
+-- requires: schemas/status_public/schema
+
+BEGIN;
+
+CREATE TABLE status_public.user_steps (
+    id uuid PRIMARY KEY DEFAULT uuid_generate_v4 (),
+    user_id uuid NOT NULL,
+    name text NOT NULL, -- references level_requirement
+    count int NOT NULL DEFAULT 1,
+    created_at timestamptz NOT NULL DEFAULT current_timestamp
+);
+
+COMMENT ON TABLE status_public.user_steps IS 'The user achieving a requirement for a level. Log table that has every single step ever taken.';
+CREATE INDEX ON status_public.user_steps (user_id, name);
+
+COMMIT;

package/deploy/schemas/status_public/tables/user_steps/triggers/update_achievements_tg.sql

@@ -0,0 +1,25 @@
+-- Deploy schemas/status_public/tables/user_steps/triggers/update_achievements_tg to pg
+
+-- requires: schemas/status_public/schema
+-- requires: schemas/status_public/tables/user_steps/table
+-- requires: schemas/status_public/tables/user_achievements/table 
+-- requires: schemas/status_private/procedures/upsert_achievement
+
+BEGIN;
+
+CREATE FUNCTION status_private.tg_update_achievements_tg()
+RETURNS TRIGGER AS $$
+DECLARE
+BEGIN
+    PERFORM status_private.upsert_achievement(NEW.user_id, NEW.name, NEW.count);
+    RETURN NEW;
+END;
+$$
+LANGUAGE 'plpgsql' VOLATILE SECURITY DEFINER;
+
+CREATE TRIGGER update_achievements_tg
+AFTER INSERT ON status_public.user_steps
+FOR EACH ROW
+EXECUTE PROCEDURE status_private.tg_update_achievements_tg ();
+
+COMMIT;