@intentsolutionsio/supabase-pack 1.0.0 → 1.0.3

package/skills/supabase-cost-tuning/SKILL.md

@@ -1,201 +1,435 @@
 ---
 name: supabase-cost-tuning
-description: |
-  Optimize Supabase costs through tier selection, sampling, and usage monitoring.
-  Use when analyzing Supabase billing, reducing API costs,
-  or implementing usage monitoring and budget alerts.
+description: 'Optimize Supabase costs through plan selection, database tuning, storage
+  cleanup,
+
+  connection pooling, and Edge Function optimization.
+
+  Use when analyzing Supabase billing, reducing costs, right-sizing compute,
+
+  or implementing usage tracking and budget alerts.
+
   Trigger with phrases like "supabase cost", "supabase billing",
+
   "reduce supabase costs", "supabase pricing", "supabase expensive", "supabase budget".
-allowed-tools: Read, Grep
+
+  '
+allowed-tools: Read, Write, Edit, Grep, Bash(supabase:*)
 version: 1.0.0
 license: MIT
 author: Jeremy Longshore <jeremy@intentsolutions.io>
+tags:
+- saas
+- supabase
+- cost-optimization
+compatibility: Designed for Claude Code, also compatible with Codex and OpenClaw
 ---
-
 # Supabase Cost Tuning
 
 ## Overview
-Optimize Supabase costs through smart tier selection, sampling, and usage monitoring.
+
+Reduce Supabase spend by auditing usage against plan limits, eliminating database and storage waste, and right-sizing compute resources. The three biggest levers: database optimization (vacuum, index cleanup, archival), storage lifecycle management (compress before upload, orphan cleanup), and connection pooling to reduce compute add-on requirements.
 
 ## Prerequisites
-- Access to Supabase billing dashboard
-- Understanding of current usage patterns
-- Database for usage tracking (optional)
-- Alerting system configured (optional)
 
-## Pricing Tiers
+- Supabase project with Dashboard access (Settings > Billing)
+- `@supabase/supabase-js` installed: `npm install @supabase/supabase-js`
+- Service role key for admin operations (storage audit, cleanup scripts)
+- SQL editor access (Dashboard > SQL Editor or `psql` connection)
+
+## Pricing Reference
+
+| Resource | Free Tier | Pro ($25/mo) | Team ($599/mo) |
+|----------|-----------|--------------|----------------|
+| Database | 500 MB | 8 GB included, $0.125/GB extra | 8 GB included |
+| Storage | 1 GB | 100 GB included, $0.021/GB extra | 100 GB included |
+| Bandwidth | 5 GB | 250 GB included, $0.09/GB extra | 250 GB included |
+| Edge Functions | 500K invocations | 2M invocations, $2/million extra | 2M invocations |
+| Realtime | 200 concurrent | 500 concurrent | 500 concurrent |
+| Auth MAU | 50,000 | 100,000 | 100,000 |
+
+**Compute add-ons** (Pro and above):
+
+| Instance | vCPUs | RAM | Price |
+|----------|-------|-----|-------|
+| Micro | 2 | 1 GB | Included with Pro |
+| Small | 2 | 2 GB | $25/mo |
+| Medium | 2 | 4 GB | $50/mo |
+| Large | 4 | 8 GB | $100/mo |
+| XL | 8 | 16 GB | $200/mo |
+| 2XL | 16 | 32 GB | $400/mo |
+
+**Decision framework:** Read replicas ($25/mo each) beat scaling up when reads dominate and you need geographic distribution. Connection pooling (Supavisor, free) reduces compute pressure from idle connections.
+
+## Instructions
+
+### Step 1: Audit Current Usage and Identify Cost Drivers
+
+Run these queries in the SQL Editor to understand where your database budget is going:
 
-| Tier | Monthly Cost | Included | Overage |
-|------|-------------|----------|---------|
-| Free | $0 | 500MB database, 1GB storage, 50K MAUs | N/A |
-| Pro | $25 | 8GB database, 100GB storage, 100K MAUs | $0.001/request |
-| Enterprise | Custom | Unlimited | Volume discounts |
+```sql
+-- Total database size
+select pg_size_pretty(pg_database_size(current_database())) as total_db_size;
+
+-- Database size by table (find the biggest offenders)
+select
+  relname as table_name,
+  pg_size_pretty(pg_total_relation_size(relid)) as total_size,
+  pg_size_pretty(pg_relation_size(relid)) as table_size,
+  pg_size_pretty(pg_total_relation_size(relid) - pg_relation_size(relid)) as index_size,
+  n_live_tup as row_count
+from pg_stat_user_tables
+order by pg_total_relation_size(relid) desc
+limit 20;
+
+-- Find unused indexes consuming space (zero scans since last stats reset)
+select
+  schemaname || '.' || indexrelname as index_name,
+  pg_size_pretty(pg_relation_size(indexrelid)) as size,
+  idx_scan as scans_since_reset
+from pg_stat_user_indexes
+where idx_scan = 0
+  and schemaname = 'public'
+order by pg_relation_size(indexrelid) desc
+limit 10;
+
+-- Check dead tuple bloat (high ratio means VACUUM is needed)
+select
+  relname,
+  n_dead_tup,
+  n_live_tup,
+  round(n_dead_tup::numeric / greatest(n_live_tup, 1) * 100, 1) as dead_pct
+from pg_stat_user_tables
+where n_dead_tup > 1000
+order by n_dead_tup desc;
+
+-- Connection count (high count may indicate pooling issues)
+select count(*) as active_connections,
+  max_conn as max_allowed
+from pg_stat_activity,
+  (select setting::int as max_conn from pg_settings where name = 'max_connections') mc
+group by max_conn;
+```
 
-## Cost Estimation
+Audit storage usage programmatically:
 
 ```typescript
-interface UsageEstimate {
-  requestsPerMonth: number;
-  tier: string;
-  estimatedCost: number;
-  recommendation?: string;
-}
+import { createClient } from '@supabase/supabase-js'
 
-function estimateSupabaseCost(requestsPerMonth: number): UsageEstimate {
-  if (requestsPerMonth <= 1000) {
-    return { requestsPerMonth, tier: 'Free', estimatedCost: 0 };
-  }
+const supabaseAdmin = createClient(
+  process.env.SUPABASE_URL!,
+  process.env.SUPABASE_SERVICE_ROLE_KEY!
+)
 
-  if (requestsPerMonth <= 100000) {
-    return { requestsPerMonth, tier: 'Pro', estimatedCost: 25 };
-  }
+// List storage usage per bucket
+const { data: buckets } = await supabaseAdmin.storage.listBuckets()
 
-  const proOverage = (requestsPerMonth - 100000) * 0.001;
-  const proCost = 25 + proOverage;
-
-  return {
-    requestsPerMonth,
-    tier: 'Pro (with overage)',
-    estimatedCost: proCost,
-    recommendation: proCost > 500
-      ? 'Consider Enterprise tier for volume discounts'
-      : undefined,
-  };
+for (const bucket of buckets ?? []) {
+  const { data: files } = await supabaseAdmin.storage
+    .from(bucket.name)
+    .list('', { limit: 1000 })
+
+  const totalSize = files?.reduce((sum, f) => sum + (f.metadata?.size || 0), 0) ?? 0
+  console.log(`${bucket.name}: ${(totalSize / 1024 / 1024).toFixed(1)} MB`)
 }
 ```
 
-## Usage Monitoring
+Check your current spend: **Dashboard > Settings > Billing** shows usage against plan limits with a breakdown by resource category.
 
-```typescript
-class SupabaseUsageMonitor {
-  private requestCount = 0;
-  private bytesTransferred = 0;
-  private alertThreshold: number;
+### Step 2: Optimize Database, Storage, and Bandwidth
 
-  constructor(monthlyBudget: number) {
-    this.alertThreshold = monthlyBudget * 0.8; // 80% warning
-  }
+**Database optimization — reclaim space and reduce bloat:**
 
-  track(request: { bytes: number }) {
-    this.requestCount++;
-    this.bytesTransferred += request.bytes;
+```sql
+-- Archive old data before deleting (preserve for compliance/analytics)
+create table if not exists public.events_archive (like public.events including all);
 
-    if (this.estimatedCost() > this.alertThreshold) {
-      this.sendAlert('Approaching Supabase budget limit');
-    }
-  }
+insert into public.events_archive
+select * from public.events
+where created_at < now() - interval '6 months';
 
-  estimatedCost(): number {
-    return estimateSupabaseCost(this.requestCount).estimatedCost;
-  }
+delete from public.events
+where created_at < now() - interval '6 months';
 
-  private sendAlert(message: string) {
-    // Send to Slack, email, PagerDuty, etc.
-  }
-}
+-- Run VACUUM ANALYZE to reclaim space and update query planner stats
+vacuum (verbose, analyze) public.events;
+
+-- Drop confirmed-unused indexes (verify idx_scan = 0 from Step 1)
+-- WARNING: always confirm the index is unused before dropping
+drop index if exists idx_events_legacy_status;
+
+-- Remove soft-deleted records past retention period
+delete from public.orders
+where deleted_at is not null
+  and deleted_at < now() - interval '90 days';
+
+vacuum (analyze) public.orders;
 ```
 
-## Cost Reduction Strategies
+**Storage optimization — compress before upload, clean orphans:**
 
-### Step 1: Request Sampling
 ```typescript
-function shouldSample(samplingRate = 0.1): boolean {
-  return Math.random() < samplingRate;
+// Compress images before upload (reduces storage + bandwidth)
+async function uploadCompressed(
+  bucket: string,
+  path: string,
+  file: File
+): Promise<string> {
+  // Use client-side compression before uploading
+  const compressed = await compressImage(file, { maxWidth: 1920, quality: 0.8 })
+
+  const { data, error } = await supabaseAdmin.storage
+    .from(bucket)
+    .upload(path, compressed, {
+      contentType: file.type,
+      upsert: true,
+    })
+
+  if (error) throw error
+  return data.path
 }
 
-// Use for non-critical telemetry
-if (shouldSample(0.1)) { // 10% sample
-  await supabaseClient.trackEvent(event);
+// Clean orphaned files older than 30 days
+async function cleanOrphanedUploads() {
+  const cutoff = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString()
+
+  const { data: orphans } = await supabaseAdmin
+    .from('storage.objects')
+    .select('name, created_at')
+    .eq('bucket_id', 'uploads')
+    .lt('created_at', cutoff)
+
+  if (orphans?.length) {
+    const paths = orphans.map(o => o.name)
+    // Delete in batches of 100
+    for (let i = 0; i < paths.length; i += 100) {
+      await supabaseAdmin.storage
+        .from('uploads')
+        .remove(paths.slice(i, i + 100))
+    }
+    console.log(`Cleaned ${orphans.length} orphaned files`)
+  }
 }
 ```
 
-### Step 2: Batching Requests
-```typescript
-// Instead of N individual calls
-await Promise.all(ids.map(id => supabaseClient.get(id)));
+**Bandwidth reduction — select only what you need:**
 
-// Use batch endpoint (1 call)
-await supabaseClient.batchGet(ids);
+```typescript
+// BAD: transfers entire row (wastes bandwidth)
+const { data } = await supabase.from('products').select('*')
+
+// GOOD: request only needed columns
+const { data } = await supabase.from('products').select('id, name, price')
+
+// Use count queries for totals (head: true = zero data transferred)
+const { count } = await supabase
+  .from('orders')
+  .select('*', { count: 'exact', head: true })
+
+// Paginate large result sets
+const { data } = await supabase
+  .from('logs')
+  .select('id, message, created_at')
+  .order('created_at', { ascending: false })
+  .range(0, 49)  // 50 rows per page
 ```
 
-### Step 3: Caching (from P16)
-- Cache frequently accessed data
-- Use cache invalidation webhooks
-- Set appropriate TTLs
+### Step 3: Right-Size Compute and Reduce Edge Function Costs
+
+**Connection pooling with Supavisor** (reduces need for compute upgrades):
 
-### Step 4: Compression
 ```typescript
-const client = new SupabaseClient({
-  compression: true, // Enable gzip
-});
+// Use the pooler connection string instead of direct connection
+// Dashboard > Settings > Database > Connection string > Mode: Transaction
+
+// In your app, use the pooled connection URL (port 6543)
+// Direct:   postgresql://postgres:pw@db.xxx.supabase.co:5432/postgres
+// Pooled:   postgresql://postgres:pw@db.xxx.supabase.co:6543/postgres
+
+// For @supabase/supabase-js, connection pooling is handled automatically
+// For direct pg connections (migrations, ORMs), use pooled URL:
+const pool = new Pool({
+  connectionString: process.env.DATABASE_URL,  // Use pooler URL
+  max: 10,  // Limit client-side pool size too
+})
 ```
 
-## Budget Alerts
+**Edge Function cold start reduction:**
 
-```bash
-# Set up billing alerts in Supabase dashboard
-# Or use API if available:
-# Check Supabase documentation for billing APIs
-```
+```typescript
+// Minimize cold starts — keep imports lightweight
+// BAD: importing heavy libraries unconditionally
+import { parse } from 'some-huge-csv-library'
 
-## Cost Dashboard Query
+// GOOD: dynamic import only when needed
+Deno.serve(async (req) => {
+  const { action } = await req.json()
 
-```sql
--- If tracking usage in your database
-SELECT
-  DATE_TRUNC('day', created_at) as date,
-  COUNT(*) as requests,
-  SUM(response_bytes) as bytes,
-  COUNT(*) * 0.001 as estimated_cost
-FROM supabase_api_logs
-WHERE created_at >= NOW() - INTERVAL '30 days'
-GROUP BY 1
-ORDER BY 1;
-```
+  if (action === 'parse-csv') {
+    const { parse } = await import('some-huge-csv-library')
+    return new Response(JSON.stringify(parse(data)))
+  }
 
-## Instructions
+  // Fast path: no heavy import needed
+  return new Response(JSON.stringify({ status: 'ok' }))
+})
 
-### Step 1: Analyze Current Usage
-Review Supabase dashboard for usage patterns and costs.
+// Cache expensive computations across invocations
+// Deno Deploy isolates persist for ~60 seconds between requests
+const _cache = new Map<string, { data: unknown; ts: number }>()
 
-### Step 2: Select Optimal Tier
-Use the cost estimation function to find the right tier.
+function cached<T>(key: string, ttlMs: number, fn: () => T): T {
+  const entry = _cache.get(key)
+  if (entry && Date.now() - entry.ts < ttlMs) return entry.data as T
+  const data = fn()
+  _cache.set(key, { data, ts: Date.now() })
+  return data
+}
+```
 
-### Step 3: Implement Monitoring
-Add usage tracking to catch budget overruns early.
+**Usage monitoring — track spend with a lightweight counter:**
 
-### Step 4: Apply Optimizations
-Enable batching, caching, and sampling where appropriate.
+```sql
+-- Create usage tracking table
+create table public.api_usage (
+  id bigint generated always as identity primary key,
+  endpoint text not null,
+  method text not null,
+  user_id uuid references auth.users(id),
+  response_bytes int default 0,
+  created_at timestamptz default now()
+);
+
+-- Create partitioned index for efficient time-range queries
+create index idx_api_usage_created on public.api_usage (created_at desc);
+
+-- Materialized view for daily cost estimation
+create materialized view public.daily_usage_summary as
+select
+  date_trunc('day', created_at) as day,
+  endpoint,
+  count(*) as requests,
+  sum(response_bytes) as total_bytes
+from public.api_usage
+group by 1, 2;
+
+-- Auto-refresh via pg_cron (enable extension first)
+select cron.schedule(
+  'refresh-usage-summary',
+  '0 1 * * *',
+  'refresh materialized view concurrently public.daily_usage_summary;'
+);
+```
 
 ## Output
-- Optimized tier selection
-- Usage monitoring implemented
-- Budget alerts configured
-- Cost reduction strategies applied
+
+After completing all three steps, you will have:
+
+- Database size audit with table-level breakdown and dead tuple analysis
+- Unused indexes identified and dropped to reclaim storage
+- Old data archived and vacuumed to free database space
+- Storage orphans cleaned and upload compression implemented
+- Bandwidth reduced through column selection and pagination
+- Connection pooling configured to avoid unnecessary compute upgrades
+- Edge Function cold starts minimized with dynamic imports and caching
+- Usage monitoring table and daily summary view for spend visibility
 
 ## Error Handling
+
 | Issue | Cause | Solution |
 |-------|-------|----------|
-| Unexpected charges | Untracked usage | Implement monitoring |
-| Overage fees | Wrong tier | Upgrade tier |
-| Budget exceeded | No alerts | Set up alerts |
-| Inefficient usage | No batching | Enable batch requests |
+| Database approaching 500 MB (Free) or 8 GB (Pro) | Data growth without archival | Archive old records, VACUUM, drop unused indexes |
+| Storage costs climbing monthly | Orphaned uploads accumulating | Schedule cleanup job for files not linked to records |
+| Unexpected bandwidth spike | `select('*')` on large tables | Use specific column lists; add `.range()` pagination |
+| Edge Function billing spike | Retry loops or heavy imports | Add circuit breaker with max 3 retries; dynamic imports |
+| Connection limit errors | Too many direct connections | Switch to pooler URL (port 6543); reduce client pool size |
+| Spend cap reached | Usage exceeded Pro included resources | Enable spend cap in Dashboard > Settings > Billing to prevent overage |
+| VACUUM not reclaiming space | Long-running transactions holding locks | Check `pg_stat_activity` for idle-in-transaction; terminate stale sessions |
 
 ## Examples
 
-### Quick Cost Check
+**Quick cost check for a growing project:**
+
 ```typescript
-// Estimate monthly cost for your usage
-const estimate = estimateSupabaseCost(yourMonthlyRequests);
-console.log(`Tier: ${estimate.tier}, Cost: $${estimate.estimatedCost}`);
-if (estimate.recommendation) {
-  console.log(`💡 ${estimate.recommendation}`);
+import { createClient } from '@supabase/supabase-js'
+
+const supabase = createClient(
+  process.env.SUPABASE_URL!,
+  process.env.SUPABASE_SERVICE_ROLE_KEY!
+)
+
+// Check database size against plan limit
+const { data: dbSize } = await supabase.rpc('get_db_size')
+// CREATE FUNCTION get_db_size() RETURNS text AS $$
+//   SELECT pg_size_pretty(pg_database_size(current_database()));
+// $$ LANGUAGE sql;
+
+console.log(`Database size: ${dbSize}`)
+
+// Check if you're approaching storage limits
+const { data: buckets } = await supabase.storage.listBuckets()
+console.log(`Storage buckets: ${buckets?.length ?? 0}`)
+```
+
+**Monthly cost estimation script:**
+
+```typescript
+function estimateMonthlyCost(usage: {
+  dbSizeGb: number
+  storageGb: number
+  bandwidthGb: number
+  edgeFnInvocations: number
+  mau: number
+}) {
+  const pro = {
+    base: 25,
+    dbOverage: Math.max(0, usage.dbSizeGb - 8) * 0.125,
+    storageOverage: Math.max(0, usage.storageGb - 100) * 0.021,
+    bandwidthOverage: Math.max(0, usage.bandwidthGb - 250) * 0.09,
+    edgeFnOverage: Math.max(0, usage.edgeFnInvocations - 2_000_000) / 1_000_000 * 2,
+  }
+
+  const total = pro.base + pro.dbOverage + pro.storageOverage
+    + pro.bandwidthOverage + pro.edgeFnOverage
+
+  console.log('Estimated monthly cost breakdown:')
+  console.log(`  Base Pro plan:     $${pro.base}`)
+  console.log(`  DB overage:        $${pro.dbOverage.toFixed(2)}`)
+  console.log(`  Storage overage:   $${pro.storageOverage.toFixed(2)}`)
+  console.log(`  Bandwidth overage: $${pro.bandwidthOverage.toFixed(2)}`)
+  console.log(`  Edge Fn overage:   $${pro.edgeFnOverage.toFixed(2)}`)
+  console.log(`  TOTAL:             $${total.toFixed(2)}/mo`)
+
+  return total
 }
+
+// Example: project with 12GB DB, 150GB storage, 300GB bandwidth
+estimateMonthlyCost({
+  dbSizeGb: 12,
+  storageGb: 150,
+  bandwidthGb: 300,
+  edgeFnInvocations: 1_500_000,
+  mau: 80_000,
+})
+// Base Pro plan:     $25
+// DB overage:        $0.50
+// Storage overage:   $1.05
+// Bandwidth overage: $4.50
+// Edge Fn overage:   $0.00
+// TOTAL:             $31.05/mo
 ```
 
 ## Resources
-- [Supabase Pricing](https://supabase.com/pricing)
-- [Supabase Billing Dashboard](https://dashboard.supabase.com/billing)
+
+- [Supabase Pricing](https://supabase.com/pricing) — plan comparison and calculator
+- [Compute Add-ons](https://supabase.com/docs/guides/platform/compute-add-ons) — instance sizing guide
+- [Spend Cap](https://supabase.com/docs/guides/platform/spend-cap) — prevent unexpected overage charges
+- [Database Disk Usage](https://supabase.com/docs/guides/platform/database-size) — monitoring and management
+- [Connection Pooling (Supavisor)](https://supabase.com/docs/guides/database/connecting-to-postgres#connection-pooler) — reduce connection overhead
+- [Edge Functions Best Practices](https://supabase.com/docs/guides/functions/best-practices) — cold start and performance tips
+- [supabase-js Reference](https://supabase.com/docs/reference/javascript/introduction) — `createClient` and SDK patterns
 
 ## Next Steps
-For architecture patterns, see `supabase-reference-architecture`.
+
+For architecture patterns, see `supabase-reference-architecture`.
+For performance tuning beyond cost, see `supabase-performance-tuning`.

package/skills/supabase-cost-tuning/references/cost-estimation.md

@@ -0,0 +1,34 @@
+# Cost Estimation
+
+## Cost Estimation
+
+```typescript
+interface UsageEstimate {
+  requestsPerMonth: number;
+  tier: string;
+  estimatedCost: number;
+  recommendation?: string;
+}
+
+function estimateSupabaseCost(requestsPerMonth: number): UsageEstimate {
+  if (requestsPerMonth <= 1000) {
+    return { requestsPerMonth, tier: 'Free', estimatedCost: 0 };
+  }
+
+  if (requestsPerMonth <= 100000) {
+    return { requestsPerMonth, tier: 'Pro', estimatedCost: 25 };
+  }
+
+  const proOverage = (requestsPerMonth - 100000) * 0.001;
+  const proCost = 25 + proOverage;
+
+  return {
+    requestsPerMonth,
+    tier: 'Pro (with overage)',
+    estimatedCost: proCost,
+    recommendation: proCost > 500
+      ? 'Consider Enterprise tier for volume discounts'
+      : undefined,
+  };
+}
+```

package/skills/supabase-cost-tuning/references/cost-reduction-strategies.md

@@ -0,0 +1,40 @@
+# Cost Reduction Strategies
+
+## Cost Reduction Strategies
+
+### Step 1: Request Sampling
+
+```typescript
+function shouldSample(samplingRate = 0.1): boolean {
+  return Math.random() < samplingRate;
+}
+
+// Use for non-critical telemetry
+if (shouldSample(0.1)) { // 10% sample
+  await supabaseClient.trackEvent(event);
+}
+```
+
+### Step 2: Batching Requests
+
+```typescript
+// Instead of N individual calls
+await Promise.all(ids.map(id => supabaseClient.get(id)));
+
+// Use batch endpoint (1 call)
+await supabaseClient.batchGet(ids);
+```
+
+### Step 3: Caching (from P16)
+
+- Cache frequently accessed data
+- Use cache invalidation webhooks
+- Set appropriate TTLs
+
+### Step 4: Compression
+
+```typescript
+const client = new SupabaseClient({
+  compression: true, // Enable gzip
+});
+```

package/skills/supabase-cost-tuning/references/errors.md

@@ -0,0 +1,11 @@
+# Error Handling Reference
+
+| Issue | Cause | Solution |
+|-------|-------|----------|
+| Unexpected charges | Untracked usage | Implement monitoring |
+| Overage fees | Wrong tier | Upgrade tier |
+| Budget exceeded | No alerts | Set up alerts |
+| Inefficient usage | No batching | Enable batch requests |
+
+---
+*[Tons of Skills](https://tonsofskills.com) by [Intent Solutions](https://intentsolutions.io) | [jeremylongshore.com](https://jeremylongshore.com)*

package/skills/supabase-cost-tuning/references/examples.md

@@ -0,0 +1,15 @@
+## Examples
+
+### Quick Cost Check
+
+```typescript
+// Estimate monthly cost for your usage
+const estimate = estimateSupabaseCost(yourMonthlyRequests);
+console.log(`Tier: ${estimate.tier}, Cost: $${estimate.estimatedCost}`);
+if (estimate.recommendation) {
+  console.log(`💡 ${estimate.recommendation}`);
+}
+```
+
+---
+*[Tons of Skills](https://tonsofskills.com) by [Intent Solutions](https://intentsolutions.io) | [jeremylongshore.com](https://jeremylongshore.com)*