jorgex-stack 1.0.1 → 1.0.3

package/stack/skills/supabase-postgres-best-practices/references/data-pagination.md

@@ -1,50 +1,50 @@
----
-title: Use Cursor-Based Pagination Instead of OFFSET
-impact: MEDIUM-HIGH
-impactDescription: Consistent O(1) performance regardless of page depth
-tags: pagination, cursor, keyset, offset, performance
----
-
-## Use Cursor-Based Pagination Instead of OFFSET
-
-OFFSET-based pagination scans all skipped rows, getting slower on deeper pages. Cursor pagination is O(1).
-
-**Incorrect (OFFSET pagination):**
-
-```sql
--- Page 1: scans 20 rows
-select * from products order by id limit 20 offset 0;
-
--- Page 100: scans 2000 rows to skip 1980
-select * from products order by id limit 20 offset 1980;
-
--- Page 10000: scans 200,000 rows!
-select * from products order by id limit 20 offset 199980;
-```
-
-**Correct (cursor/keyset pagination):**
-
-```sql
--- Page 1: get first 20
-select * from products order by id limit 20;
--- Application stores last_id = 20
-
--- Page 2: start after last ID
-select * from products where id > 20 order by id limit 20;
--- Uses index, always fast regardless of page depth
-
--- Page 10000: same speed as page 1
-select * from products where id > 199980 order by id limit 20;
-```
-
-For multi-column sorting:
-
-```sql
--- Cursor must include all sort columns
-select * from products
-where (created_at, id) > ('2024-01-15 10:00:00', 12345)
-order by created_at, id
-limit 20;
-```
-
-Reference: [Pagination](https://supabase.com/docs/guides/database/pagination)
+---
+title: Use Cursor-Based Pagination Instead of OFFSET
+impact: MEDIUM-HIGH
+impactDescription: Consistent O(1) performance regardless of page depth
+tags: pagination, cursor, keyset, offset, performance
+---
+
+## Use Cursor-Based Pagination Instead of OFFSET
+
+OFFSET-based pagination scans all skipped rows, getting slower on deeper pages. Cursor pagination is O(1).
+
+**Incorrect (OFFSET pagination):**
+
+```sql
+-- Page 1: scans 20 rows
+select * from products order by id limit 20 offset 0;
+
+-- Page 100: scans 2000 rows to skip 1980
+select * from products order by id limit 20 offset 1980;
+
+-- Page 10000: scans 200,000 rows!
+select * from products order by id limit 20 offset 199980;
+```
+
+**Correct (cursor/keyset pagination):**
+
+```sql
+-- Page 1: get first 20
+select * from products order by id limit 20;
+-- Application stores last_id = 20
+
+-- Page 2: start after last ID
+select * from products where id > 20 order by id limit 20;
+-- Uses index, always fast regardless of page depth
+
+-- Page 10000: same speed as page 1
+select * from products where id > 199980 order by id limit 20;
+```
+
+For multi-column sorting:
+
+```sql
+-- Cursor must include all sort columns
+select * from products
+where (created_at, id) > ('2024-01-15 10:00:00', 12345)
+order by created_at, id
+limit 20;
+```
+
+Reference: [Pagination](https://supabase.com/docs/guides/database/pagination)

package/stack/skills/supabase-postgres-best-practices/references/data-upsert.md

@@ -1,50 +1,50 @@
----
-title: Use UPSERT for Insert-or-Update Operations
-impact: MEDIUM
-impactDescription: Atomic operation, eliminates race conditions
-tags: upsert, on-conflict, insert, update
----
-
-## Use UPSERT for Insert-or-Update Operations
-
-Using separate SELECT-then-INSERT/UPDATE creates race conditions. Use INSERT ... ON CONFLICT for atomic upserts.
-
-**Incorrect (check-then-insert race condition):**
-
-```sql
--- Race condition: two requests check simultaneously
-select * from settings where user_id = 123 and key = 'theme';
--- Both find nothing
-
--- Both try to insert
-insert into settings (user_id, key, value) values (123, 'theme', 'dark');
--- One succeeds, one fails with duplicate key error!
-```
-
-**Correct (atomic UPSERT):**
-
-```sql
--- Single atomic operation
-insert into settings (user_id, key, value)
-values (123, 'theme', 'dark')
-on conflict (user_id, key)
-do update set value = excluded.value, updated_at = now();
-
--- Returns the inserted/updated row
-insert into settings (user_id, key, value)
-values (123, 'theme', 'dark')
-on conflict (user_id, key)
-do update set value = excluded.value
-returning *;
-```
-
-Insert-or-ignore pattern:
-
-```sql
--- Insert only if not exists (no update)
-insert into page_views (page_id, user_id)
-values (1, 123)
-on conflict (page_id, user_id) do nothing;
-```
-
-Reference: [INSERT ON CONFLICT](https://www.postgresql.org/docs/current/sql-insert.html#SQL-ON-CONFLICT)
+---
+title: Use UPSERT for Insert-or-Update Operations
+impact: MEDIUM
+impactDescription: Atomic operation, eliminates race conditions
+tags: upsert, on-conflict, insert, update
+---
+
+## Use UPSERT for Insert-or-Update Operations
+
+Using separate SELECT-then-INSERT/UPDATE creates race conditions. Use INSERT ... ON CONFLICT for atomic upserts.
+
+**Incorrect (check-then-insert race condition):**
+
+```sql
+-- Race condition: two requests check simultaneously
+select * from settings where user_id = 123 and key = 'theme';
+-- Both find nothing
+
+-- Both try to insert
+insert into settings (user_id, key, value) values (123, 'theme', 'dark');
+-- One succeeds, one fails with duplicate key error!
+```
+
+**Correct (atomic UPSERT):**
+
+```sql
+-- Single atomic operation
+insert into settings (user_id, key, value)
+values (123, 'theme', 'dark')
+on conflict (user_id, key)
+do update set value = excluded.value, updated_at = now();
+
+-- Returns the inserted/updated row
+insert into settings (user_id, key, value)
+values (123, 'theme', 'dark')
+on conflict (user_id, key)
+do update set value = excluded.value
+returning *;
+```
+
+Insert-or-ignore pattern:
+
+```sql
+-- Insert only if not exists (no update)
+insert into page_views (page_id, user_id)
+values (1, 123)
+on conflict (page_id, user_id) do nothing;
+```
+
+Reference: [INSERT ON CONFLICT](https://www.postgresql.org/docs/current/sql-insert.html#SQL-ON-CONFLICT)

package/stack/skills/supabase-postgres-best-practices/references/lock-advisory.md

@@ -1,56 +1,56 @@
----
-title: Use Advisory Locks for Application-Level Locking
-impact: MEDIUM
-impactDescription: Efficient coordination without row-level lock overhead
-tags: advisory-locks, coordination, application-locks
----
-
-## Use Advisory Locks for Application-Level Locking
-
-Advisory locks provide application-level coordination without requiring database rows to lock.
-
-**Incorrect (creating rows just for locking):**
-
-```sql
--- Creating dummy rows to lock on
-create table resource_locks (
-  resource_name text primary key
-);
-
-insert into resource_locks values ('report_generator');
-
--- Lock by selecting the row
-select * from resource_locks where resource_name = 'report_generator' for update;
-```
-
-**Correct (advisory locks):**
-
-```sql
--- Session-level advisory lock (released on disconnect or unlock)
-select pg_advisory_lock(hashtext('report_generator'));
--- ... do exclusive work ...
-select pg_advisory_unlock(hashtext('report_generator'));
-
--- Transaction-level lock (released on commit/rollback)
-begin;
-select pg_advisory_xact_lock(hashtext('daily_report'));
--- ... do work ...
-commit;  -- Lock automatically released
-```
-
-Try-lock for non-blocking operations:
-
-```sql
--- Returns immediately with true/false instead of waiting
-select pg_try_advisory_lock(hashtext('resource_name'));
-
--- Use in application
-if (acquired) {
-  -- Do work
-  select pg_advisory_unlock(hashtext('resource_name'));
-} else {
-  -- Skip or retry later
-}
-```
-
-Reference: [Advisory Locks](https://www.postgresql.org/docs/current/explicit-locking.html#ADVISORY-LOCKS)
+---
+title: Use Advisory Locks for Application-Level Locking
+impact: MEDIUM
+impactDescription: Efficient coordination without row-level lock overhead
+tags: advisory-locks, coordination, application-locks
+---
+
+## Use Advisory Locks for Application-Level Locking
+
+Advisory locks provide application-level coordination without requiring database rows to lock.
+
+**Incorrect (creating rows just for locking):**
+
+```sql
+-- Creating dummy rows to lock on
+create table resource_locks (
+  resource_name text primary key
+);
+
+insert into resource_locks values ('report_generator');
+
+-- Lock by selecting the row
+select * from resource_locks where resource_name = 'report_generator' for update;
+```
+
+**Correct (advisory locks):**
+
+```sql
+-- Session-level advisory lock (released on disconnect or unlock)
+select pg_advisory_lock(hashtext('report_generator'));
+-- ... do exclusive work ...
+select pg_advisory_unlock(hashtext('report_generator'));
+
+-- Transaction-level lock (released on commit/rollback)
+begin;
+select pg_advisory_xact_lock(hashtext('daily_report'));
+-- ... do work ...
+commit;  -- Lock automatically released
+```
+
+Try-lock for non-blocking operations:
+
+```sql
+-- Returns immediately with true/false instead of waiting
+select pg_try_advisory_lock(hashtext('resource_name'));
+
+-- Use in application
+if (acquired) {
+  -- Do work
+  select pg_advisory_unlock(hashtext('resource_name'));
+} else {
+  -- Skip or retry later
+}
+```
+
+Reference: [Advisory Locks](https://www.postgresql.org/docs/current/explicit-locking.html#ADVISORY-LOCKS)

package/stack/skills/supabase-postgres-best-practices/references/lock-deadlock-prevention.md

@@ -1,68 +1,68 @@
----
-title: Prevent Deadlocks with Consistent Lock Ordering
-impact: MEDIUM-HIGH
-impactDescription: Eliminate deadlock errors, improve reliability
-tags: deadlocks, locking, transactions, ordering
----
-
-## Prevent Deadlocks with Consistent Lock Ordering
-
-Deadlocks occur when transactions lock resources in different orders. Always
-acquire locks in a consistent order.
-
-**Incorrect (inconsistent lock ordering):**
-
-```sql
--- Transaction A                    -- Transaction B
-begin;                              begin;
-update accounts                     update accounts
-set balance = balance - 100         set balance = balance - 50
-where id = 1;                       where id = 2;  -- B locks row 2
-
-update accounts                     update accounts
-set balance = balance + 100         set balance = balance + 50
-where id = 2;  -- A waits for B     where id = 1;  -- B waits for A
-
--- DEADLOCK! Both waiting for each other
-```
-
-**Correct (lock rows in consistent order first):**
-
-```sql
--- Explicitly acquire locks in ID order before updating
-begin;
-select * from accounts where id in (1, 2) order by id for update;
-
--- Now perform updates in any order - locks already held
-update accounts set balance = balance - 100 where id = 1;
-update accounts set balance = balance + 100 where id = 2;
-commit;
-```
-
-Alternative: use a single statement to update atomically:
-
-```sql
--- Single statement acquires all locks atomically
-begin;
-update accounts
-set balance = balance + case id
-  when 1 then -100
-  when 2 then 100
-end
-where id in (1, 2);
-commit;
-```
-
-Detect deadlocks in logs:
-
-```sql
--- Check for recent deadlocks
-select * from pg_stat_database where deadlocks > 0;
-
--- Enable deadlock logging
-set log_lock_waits = on;
-set deadlock_timeout = '1s';
-```
-
-Reference:
-[Deadlocks](https://www.postgresql.org/docs/current/explicit-locking.html#LOCKING-DEADLOCKS)
+---
+title: Prevent Deadlocks with Consistent Lock Ordering
+impact: MEDIUM-HIGH
+impactDescription: Eliminate deadlock errors, improve reliability
+tags: deadlocks, locking, transactions, ordering
+---
+
+## Prevent Deadlocks with Consistent Lock Ordering
+
+Deadlocks occur when transactions lock resources in different orders. Always
+acquire locks in a consistent order.
+
+**Incorrect (inconsistent lock ordering):**
+
+```sql
+-- Transaction A                    -- Transaction B
+begin;                              begin;
+update accounts                     update accounts
+set balance = balance - 100         set balance = balance - 50
+where id = 1;                       where id = 2;  -- B locks row 2
+
+update accounts                     update accounts
+set balance = balance + 100         set balance = balance + 50
+where id = 2;  -- A waits for B     where id = 1;  -- B waits for A
+
+-- DEADLOCK! Both waiting for each other
+```
+
+**Correct (lock rows in consistent order first):**
+
+```sql
+-- Explicitly acquire locks in ID order before updating
+begin;
+select * from accounts where id in (1, 2) order by id for update;
+
+-- Now perform updates in any order - locks already held
+update accounts set balance = balance - 100 where id = 1;
+update accounts set balance = balance + 100 where id = 2;
+commit;
+```
+
+Alternative: use a single statement to update atomically:
+
+```sql
+-- Single statement acquires all locks atomically
+begin;
+update accounts
+set balance = balance + case id
+  when 1 then -100
+  when 2 then 100
+end
+where id in (1, 2);
+commit;
+```
+
+Detect deadlocks in logs:
+
+```sql
+-- Check for recent deadlocks
+select * from pg_stat_database where deadlocks > 0;
+
+-- Enable deadlock logging
+set log_lock_waits = on;
+set deadlock_timeout = '1s';
+```
+
+Reference:
+[Deadlocks](https://www.postgresql.org/docs/current/explicit-locking.html#LOCKING-DEADLOCKS)

package/stack/skills/supabase-postgres-best-practices/references/lock-short-transactions.md

@@ -1,50 +1,50 @@
----
-title: Keep Transactions Short to Reduce Lock Contention
-impact: MEDIUM-HIGH
-impactDescription: 3-5x throughput improvement, fewer deadlocks
-tags: transactions, locking, contention, performance
----
-
-## Keep Transactions Short to Reduce Lock Contention
-
-Long-running transactions hold locks that block other queries. Keep transactions as short as possible.
-
-**Incorrect (long transaction with external calls):**
-
-```sql
-begin;
-select * from orders where id = 1 for update;  -- Lock acquired
-
--- Application makes HTTP call to payment API (2-5 seconds)
--- Other queries on this row are blocked!
-
-update orders set status = 'paid' where id = 1;
-commit;  -- Lock held for entire duration
-```
-
-**Correct (minimal transaction scope):**
-
-```sql
--- Validate data and call APIs outside transaction
--- Application: response = await paymentAPI.charge(...)
-
--- Only hold lock for the actual update
-begin;
-update orders
-set status = 'paid', payment_id = $1
-where id = $2 and status = 'pending'
-returning *;
-commit;  -- Lock held for milliseconds
-```
-
-Use `statement_timeout` to prevent runaway transactions:
-
-```sql
--- Abort queries running longer than 30 seconds
-set statement_timeout = '30s';
-
--- Or per-session
-set local statement_timeout = '5s';
-```
-
-Reference: [Transaction Management](https://www.postgresql.org/docs/current/tutorial-transactions.html)
+---
+title: Keep Transactions Short to Reduce Lock Contention
+impact: MEDIUM-HIGH
+impactDescription: 3-5x throughput improvement, fewer deadlocks
+tags: transactions, locking, contention, performance
+---
+
+## Keep Transactions Short to Reduce Lock Contention
+
+Long-running transactions hold locks that block other queries. Keep transactions as short as possible.
+
+**Incorrect (long transaction with external calls):**
+
+```sql
+begin;
+select * from orders where id = 1 for update;  -- Lock acquired
+
+-- Application makes HTTP call to payment API (2-5 seconds)
+-- Other queries on this row are blocked!
+
+update orders set status = 'paid' where id = 1;
+commit;  -- Lock held for entire duration
+```
+
+**Correct (minimal transaction scope):**
+
+```sql
+-- Validate data and call APIs outside transaction
+-- Application: response = await paymentAPI.charge(...)
+
+-- Only hold lock for the actual update
+begin;
+update orders
+set status = 'paid', payment_id = $1
+where id = $2 and status = 'pending'
+returning *;
+commit;  -- Lock held for milliseconds
+```
+
+Use `statement_timeout` to prevent runaway transactions:
+
+```sql
+-- Abort queries running longer than 30 seconds
+set statement_timeout = '30s';
+
+-- Or per-session
+set local statement_timeout = '5s';
+```
+
+Reference: [Transaction Management](https://www.postgresql.org/docs/current/tutorial-transactions.html)

package/stack/skills/supabase-postgres-best-practices/references/lock-skip-locked.md

@@ -1,54 +1,54 @@
----
-title: Use SKIP LOCKED for Non-Blocking Queue Processing
-impact: MEDIUM-HIGH
-impactDescription: 10x throughput for worker queues
-tags: skip-locked, queue, workers, concurrency
----
-
-## Use SKIP LOCKED for Non-Blocking Queue Processing
-
-When multiple workers process a queue, SKIP LOCKED allows workers to process different rows without waiting.
-
-**Incorrect (workers block each other):**
-
-```sql
--- Worker 1 and Worker 2 both try to get next job
-begin;
-select * from jobs where status = 'pending' order by created_at limit 1 for update;
--- Worker 2 waits for Worker 1's lock to release!
-```
-
-**Correct (SKIP LOCKED for parallel processing):**
-
-```sql
--- Each worker skips locked rows and gets the next available
-begin;
-select * from jobs
-where status = 'pending'
-order by created_at
-limit 1
-for update skip locked;
-
--- Worker 1 gets job 1, Worker 2 gets job 2 (no waiting)
-
-update jobs set status = 'processing' where id = $1;
-commit;
-```
-
-Complete queue pattern:
-
-```sql
--- Atomic claim-and-update in one statement
-update jobs
-set status = 'processing', worker_id = $1, started_at = now()
-where id = (
-  select id from jobs
-  where status = 'pending'
-  order by created_at
-  limit 1
-  for update skip locked
-)
-returning *;
-```
-
-Reference: [SELECT FOR UPDATE SKIP LOCKED](https://www.postgresql.org/docs/current/sql-select.html#SQL-FOR-UPDATE-SHARE)
+---
+title: Use SKIP LOCKED for Non-Blocking Queue Processing
+impact: MEDIUM-HIGH
+impactDescription: 10x throughput for worker queues
+tags: skip-locked, queue, workers, concurrency
+---
+
+## Use SKIP LOCKED for Non-Blocking Queue Processing
+
+When multiple workers process a queue, SKIP LOCKED allows workers to process different rows without waiting.
+
+**Incorrect (workers block each other):**
+
+```sql
+-- Worker 1 and Worker 2 both try to get next job
+begin;
+select * from jobs where status = 'pending' order by created_at limit 1 for update;
+-- Worker 2 waits for Worker 1's lock to release!
+```
+
+**Correct (SKIP LOCKED for parallel processing):**
+
+```sql
+-- Each worker skips locked rows and gets the next available
+begin;
+select * from jobs
+where status = 'pending'
+order by created_at
+limit 1
+for update skip locked;
+
+-- Worker 1 gets job 1, Worker 2 gets job 2 (no waiting)
+
+update jobs set status = 'processing' where id = $1;
+commit;
+```
+
+Complete queue pattern:
+
+```sql
+-- Atomic claim-and-update in one statement
+update jobs
+set status = 'processing', worker_id = $1, started_at = now()
+where id = (
+  select id from jobs
+  where status = 'pending'
+  order by created_at
+  limit 1
+  for update skip locked
+)
+returning *;
+```
+
+Reference: [SELECT FOR UPDATE SKIP LOCKED](https://www.postgresql.org/docs/current/sql-select.html#SQL-FOR-UPDATE-SHARE)