@rigour-labs/core 6.8.0 → 6.8.1-rc.1

package/dist/gates/test-quality.test.js

@@ -1,325 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-const mockFindFiles = vi.hoisted(() => vi.fn());
-const mockReadFile = vi.hoisted(() => vi.fn());
-vi.mock('../utils/scanner.js', () => ({
-    FileScanner: { findFiles: mockFindFiles },
-}));
-vi.mock('fs-extra', () => ({
-    default: {
-        readFile: mockReadFile,
-        pathExists: vi.fn().mockResolvedValue(false),
-        pathExistsSync: vi.fn().mockReturnValue(false),
-        readFileSync: vi.fn().mockReturnValue(''),
-        readJson: vi.fn().mockResolvedValue(null),
-        readdirSync: vi.fn().mockReturnValue([]),
-    },
-}));
-import { TestQualityGate } from './test-quality.js';
-describe('TestQualityGate — JS/TS tests', () => {
-    let gate;
-    beforeEach(() => {
-        gate = new TestQualityGate();
-        vi.clearAllMocks();
-    });
-    it('should flag empty test bodies', async () => {
-        mockFindFiles.mockResolvedValue(['src/utils.test.ts']);
-        mockReadFile.mockResolvedValue(`
-describe('Utils', () => {
-    it('should do something', () => {
-    });
-});
-        `);
-        const failures = await gate.run({ cwd: '/project' });
-        expect(failures).toHaveLength(1);
-        expect(failures[0].details).toContain('empty-test');
-    });
-    it('should flag tests with no assertions', async () => {
-        mockFindFiles.mockResolvedValue(['src/api.test.ts']);
-        mockReadFile.mockResolvedValue(`
-describe('API', () => {
-    it('should fetch data', () => {
-        const data = fetchData();
-        console.log(data);
-    });
-});
-        `);
-        const failures = await gate.run({ cwd: '/project' });
-        expect(failures).toHaveLength(1);
-        expect(failures[0].details).toContain('no-assertion');
-    });
-    it('should not flag type-level tests, where the compiler is the assertion', async () => {
-        mockFindFiles.mockResolvedValue(['src/types.test.ts']);
-        mockReadFile.mockResolvedValue(`
-it('our document type accepts the published one', () => {
-    const _published: Document = null as unknown as Published.Document;
-});
-it('infers the output', () => {
-    expectTypeOf(output).toEqualTypeOf<string>();
-});
-        `);
-        const failures = await gate.run({ cwd: '/project' });
-        expect(failures).toHaveLength(0);
-    });
-    it('should flag tautological assertions', async () => {
-        mockFindFiles.mockResolvedValue(['src/basic.test.ts']);
-        mockReadFile.mockResolvedValue(`
-describe('Basic', () => {
-    it('should pass', () => {
-        expect(true).toBe(true);
-    });
-});
-        `);
-        const failures = await gate.run({ cwd: '/project' });
-        expect(failures).toHaveLength(1);
-        expect(failures[0].details).toContain('tautological');
-    });
-    it('should flag mock-heavy tests', async () => {
-        mockFindFiles.mockResolvedValue(['src/service.test.ts']);
-        mockReadFile.mockResolvedValue(`
-describe('Service', () => {
-    it('should process', () => {
-        const mock1 = vi.fn();
-        const mock2 = vi.fn();
-        const mock3 = vi.fn();
-        const mock4 = vi.fn();
-        const mock5 = vi.fn();
-        const mock6 = vi.fn();
-        expect(mock1).toBeDefined();
-    });
-});
-        `);
-        const failures = await gate.run({ cwd: '/project' });
-        expect(failures).toHaveLength(1);
-        expect(failures[0].details).toContain('mock-heavy');
-    });
-    it('should NOT flag well-written tests', async () => {
-        mockFindFiles.mockResolvedValue(['src/good.test.ts']);
-        mockReadFile.mockResolvedValue(`
-describe('Calculator', () => {
-    it('should add two numbers', () => {
-        const result = add(2, 3);
-        expect(result).toBe(5);
-    });
-
-    it('should handle negative numbers', () => {
-        const result = add(-1, -2);
-        expect(result).toBe(-3);
-    });
-});
-        `);
-        const failures = await gate.run({ cwd: '/project' });
-        expect(failures).toHaveLength(0);
-    });
-    it('should NOT flag tests with expect().toEqual()', async () => {
-        mockFindFiles.mockResolvedValue(['src/valid.test.ts']);
-        mockReadFile.mockResolvedValue(`
-describe('Parser', () => {
-    it('should parse JSON', () => {
-        const result = parseConfig('{"key": "value"}');
-        expect(result).toEqual({ key: 'value' });
-    });
-});
-        `);
-        const failures = await gate.run({ cwd: '/project' });
-        expect(failures).toHaveLength(0);
-    });
-    it('should not scan when disabled', async () => {
-        const disabled = new TestQualityGate({ enabled: false });
-        const failures = await disabled.run({ cwd: '/project' });
-        expect(failures).toHaveLength(0);
-        expect(mockFindFiles).not.toHaveBeenCalled();
-    });
-});
-describe('TestQualityGate — Python tests', () => {
-    let gate;
-    beforeEach(() => {
-        gate = new TestQualityGate();
-        vi.clearAllMocks();
-    });
-    it('should flag empty test functions', async () => {
-        mockFindFiles.mockResolvedValue(['test_utils.py']);
-        mockReadFile.mockResolvedValue(`
-def test_something():
-    pass
-        `);
-        const failures = await gate.run({ cwd: '/project' });
-        expect(failures).toHaveLength(1);
-        expect(failures[0].details).toContain('empty-test');
-    });
-    it('should flag tests with no assertions', async () => {
-        mockFindFiles.mockResolvedValue(['test_api.py']);
-        mockReadFile.mockResolvedValue(`
-def test_fetch_data():
-    data = fetch_data()
-    print(data)
-    result = process(data)
-        `);
-        const failures = await gate.run({ cwd: '/project' });
-        expect(failures).toHaveLength(1);
-        expect(failures[0].details).toContain('no-assertion');
-    });
-    it('should flag tautological Python assertions', async () => {
-        mockFindFiles.mockResolvedValue(['test_basic.py']);
-        mockReadFile.mockResolvedValue(`
-def test_always_passes():
-    assert True
-        `);
-        const failures = await gate.run({ cwd: '/project' });
-        expect(failures).toHaveLength(1);
-        expect(failures[0].details).toContain('tautological');
-    });
-    it('should NOT flag Python tests with real assertions', async () => {
-        mockFindFiles.mockResolvedValue(['test_calc.py']);
-        mockReadFile.mockResolvedValue(`
-def test_addition():
-    result = add(2, 3)
-    assert result == 5
-
-def test_subtraction():
-    result = subtract(5, 3)
-    assert result == 2
-        `);
-        const failures = await gate.run({ cwd: '/project' });
-        expect(failures).toHaveLength(0);
-    });
-    it('should NOT flag tests using pytest.raises', async () => {
-        mockFindFiles.mockResolvedValue(['test_errors.py']);
-        mockReadFile.mockResolvedValue(`
-def test_invalid_input():
-    with pytest.raises(ValueError):
-        parse_int("not a number")
-        `);
-        const failures = await gate.run({ cwd: '/project' });
-        expect(failures).toHaveLength(0);
-    });
-});
-describe('TestQualityGate — Go tests', () => {
-    let gate;
-    beforeEach(() => {
-        gate = new TestQualityGate();
-        vi.clearAllMocks();
-    });
-    it('should flag empty Go test functions', async () => {
-        mockFindFiles.mockResolvedValue(['utils_test.go']);
-        mockReadFile.mockResolvedValue(`
-package utils
-
-import "testing"
-
-func TestSomething(t *testing.T) {
-}
-        `);
-        const failures = await gate.run({ cwd: '/project' });
-        expect(failures).toHaveLength(1);
-        expect(failures[0].details).toContain('empty-test');
-    });
-    it('should flag Go tests without assertions', async () => {
-        mockFindFiles.mockResolvedValue(['calc_test.go']);
-        mockReadFile.mockResolvedValue(`
-package calc
-
-import "testing"
-
-func TestAdd(t *testing.T) {
-    result := Add(2, 3)
-    _ = result
-}
-        `);
-        const failures = await gate.run({ cwd: '/project' });
-        expect(failures).toHaveLength(1);
-        expect(failures[0].details).toContain('no-assertion');
-    });
-    it('should NOT flag Go tests with t.Error assertions', async () => {
-        mockFindFiles.mockResolvedValue(['good_test.go']);
-        mockReadFile.mockResolvedValue(`
-package calc
-
-import "testing"
-
-func TestAdd(t *testing.T) {
-    result := Add(2, 3)
-    if result != 5 {
-        t.Errorf("expected 5, got %d", result)
-    }
-}
-        `);
-        const failures = await gate.run({ cwd: '/project' });
-        expect(failures).toHaveLength(0);
-    });
-    it('should NOT flag Go tests with testify assertions', async () => {
-        mockFindFiles.mockResolvedValue(['testify_test.go']);
-        mockReadFile.mockResolvedValue(`
-package main
-
-import (
-    "testing"
-    "github.com/stretchr/testify/assert"
-)
-
-func TestAdd(t *testing.T) {
-    result := Add(2, 3)
-    assert.Equal(t, 5, result)
-}
-        `);
-        const failures = await gate.run({ cwd: '/project' });
-        expect(failures).toHaveLength(0);
-    });
-});
-describe('TestQualityGate — Java tests', () => {
-    let gate;
-    beforeEach(() => {
-        gate = new TestQualityGate();
-        vi.clearAllMocks();
-    });
-    it('should flag Java tests without assertions', async () => {
-        mockFindFiles.mockResolvedValue(['CalcTest.java']);
-        mockReadFile.mockResolvedValue(`
-import org.junit.jupiter.api.Test;
-
-class CalcTest {
-    @Test
-    void testAdd() {
-        int result = Calculator.add(2, 3);
-        System.out.println(result);
-    }
-}
-        `);
-        const failures = await gate.run({ cwd: '/project' });
-        expect(failures).toHaveLength(1);
-        expect(failures[0].details).toContain('no-assertion');
-    });
-    it('should NOT flag Java tests with assertions', async () => {
-        mockFindFiles.mockResolvedValue(['GoodTest.java']);
-        mockReadFile.mockResolvedValue(`
-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
-
-class GoodTest {
-    @Test
-    void testAdd() {
-        int result = Calculator.add(2, 3);
-        assertEquals(5, result);
-    }
-}
-        `);
-        const failures = await gate.run({ cwd: '/project' });
-        expect(failures).toHaveLength(0);
-    });
-    it('should flag tautological Java assertions', async () => {
-        mockFindFiles.mockResolvedValue(['TautTest.java']);
-        mockReadFile.mockResolvedValue(`
-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
-
-class TautTest {
-    @Test
-    void testAlwaysPasses() {
-        assertTrue(true);
-    }
-}
-        `);
-        const failures = await gate.run({ cwd: '/project' });
-        expect(failures.length).toBeGreaterThanOrEqual(1);
-        expect(failures[0].details).toContain('tautological');
-    });
-});

package/dist/gates/trusted-reviews.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/gates/trusted-reviews.test.js

@@ -1,16 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, describe, expect, it } from 'vitest';
-import { trustedReviews } from './deep-analysis.js';
-let cwd;
-afterEach(() => fs.rmSync(cwd, { recursive: true, force: true }));
-describe('trustedReviews', () => {
-    it('lets a normal run skip what agents recorded as reviewed, and an independent run skip nothing', () => {
-        cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'trusted-reviews-'));
-        fs.mkdirSync(path.join(cwd, '.rigour'));
-        fs.writeFileSync(path.join(cwd, '.rigour', 'reviewed.json'), JSON.stringify({ version: 1, entries: [{ file: 'src/a.ts', function: 'f', hash: 'h', reviewer: 'agent', verdict: 'no_issue' }] }));
-        expect(trustedReviews(cwd, {}).map(r => r.function)).toEqual(['f']);
-        expect(trustedReviews(cwd, { independent: true })).toEqual([]);
-    });
-});

package/dist/gates/unindexed-reads/queries.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/gates/unindexed-reads/queries.test.js

@@ -1,54 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { findReads } from './queries.js';
-const reads = (code) => findReads('a.ts', code);
-describe('findReads', () => {
-    it('models a literal supabase-js read: filters, first order column, line', () => {
-        const [read] = reads(`
-const page = await supabase
-  .from('orders')
-  .select('id, placed_at')
-  .eq('status', 'open')
-  .not('customer_id', 'is', null)
-  .gt('placed_at', since)
-  .lte('placed_at', until)
-  .order('placed_at')
-  .order('id')
-  .limit(100);`);
-        expect(read).toEqual({
-            table: 'orders', line: 3, uncertain: false, orderBy: 'placed_at',
-            filters: [
-                { column: 'status', op: 'eq', value: 'open' },
-                { column: 'customer_id', op: 'notnull' },
-                { column: 'placed_at', op: 'range' },
-                { column: 'placed_at', op: 'range' },
-            ],
-        });
-    });
-    it('reads .in, .is(null), .match and .filter, and qualifies a non-public schema', () => {
-        const [read] = reads(`db.schema('billing').from('invoices').select('*').in('id', ids).is('paid_at', null).match({ kind: 'card' }).filter('total', 'gte', 10);`);
-        expect(read.table).toBe('billing.invoices');
-        expect(read.filters).toEqual([
-            { column: 'id', op: 'in' },
-            { column: 'paid_at', op: 'isnull' },
-            { column: 'kind', op: 'eq', value: 'card' },
-            { column: 'total', op: 'range' },
-        ]);
-        expect(read.uncertain).toBe(false);
-    });
-    it('is uncertain when anything is computed, OR-ed, embedded or unknown', () => {
-        const uncertain = [
-            `db.from(table).select('*').eq('a', 1);`,
-            `db.from('t').select('*').eq(column, 1);`,
-            `db.from('t').select('*').or('a.eq.1,b.eq.2');`,
-            `db.from('t').select('*, u!inner(*)').eq('u.id', 1);`,
-            `db.from('t').select('*').someNewFilter('a', 1);`,
-            `db.schema(name).from('t').select('*').eq('a', 1);`,
-        ];
-        expect(uncertain.map(code => reads(code)[0].uncertain)).toEqual(uncertain.map(() => true));
-    });
-    it('ignores writes and calls that are not reads', () => {
-        expect(reads(`db.from('t').insert({ a: 1 }).select();`)).toEqual([]);
-        expect(reads(`db.from('t').update({ a: 1 }).eq('id', 1);`)).toEqual([]);
-        expect(reads(`Array.from(items).filter(Boolean);`)).toEqual([]);
-    });
-});

package/dist/gates/unindexed-reads/schema.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/gates/unindexed-reads/schema.test.js

@@ -1,81 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { policyColumns, policyFilters, replayMigrations } from './schema.js';
-import { splitStatements } from './sql.js';
-describe('splitStatements', () => {
-    it('keeps comments, quotes and dollar bodies from splitting a statement', () => {
-        const sql = `-- a; comment\ncreate table a (x text default ';');\n/* b; */ do $$ begin perform 1; end $$;\nselect 'it''s; fine';`;
-        expect(splitStatements(sql)).toEqual(["create table a (x text default ';')", 'do $$ begin perform 1; end $$', "select 'it''s; fine'"]);
-    });
-});
-describe('replayMigrations', () => {
-    it('collects primary keys, unique columns and table constraints as indexes', () => {
-        const schema = replayMigrations([`
-            create table public.orders (
-              id uuid primary key default gen_random_uuid(),
-              code text not null unique,
-              customer_id uuid not null references customers(id),
-              placed_at timestamptz,
-              constraint orders_customer_code unique (customer_id, code)
-            );`]);
-        expect(schema.get('orders').indexes.map(i => i.leading)).toEqual(['id', 'code', 'customer_id']);
-        expect(schema.get('orders').uncertain).toBe(false);
-    });
-    it('applies indexes, partial predicates, drops and renames in order', () => {
-        const schema = replayMigrations([
-            'create table orders (id uuid primary key, status text, placed_at timestamptz, customer_id uuid);',
-            `create index concurrently orders_open_idx on public.orders (placed_at desc, id) where status = 'open' and customer_id is not null;`,
-            'create index orders_customer_idx on orders using btree (customer_id);',
-            'create index orders_lower_idx on orders (lower(status));',
-            'drop index if exists public.orders_customer_idx;',
-            'alter index orders_open_idx rename to orders_open_v2_idx;',
-        ]);
-        const indexes = schema.get('orders').indexes;
-        expect(indexes.map(i => [i.name, i.leading])).toEqual([[undefined, 'id'], ['orders_open_v2_idx', 'placed_at'], ['orders_lower_idx', null]]);
-        expect(indexes[1].predicate).toEqual([{ kind: 'eq', column: 'status', value: 'open' }, { kind: 'notnull', column: 'customer_id' }]);
-    });
-    it('follows ALTER TABLE: added keys, table renames, dropped tables', () => {
-        const schema = replayMigrations([
-            'create table events (id bigint, kind text);',
-            'alter table events add constraint events_pkey primary key (id);',
-            'alter table events add column ref text unique;',
-            'alter table events rename to audit_events;',
-            'create table scratch (x int);',
-            'drop table scratch;',
-        ]);
-        expect(schema.get('audit_events').indexes.map(i => i.leading)).toEqual(['id', 'ref']);
-        expect([...schema.keys()]).toEqual(['audit_events']);
-    });
-    it('marks a table uncertain when DDL is beyond what it models', () => {
-        const schema = replayMigrations([
-            'create table a (id int, x int); create table b (id int); create table c (like a including indexes); create table d (id int) partition by range (id);',
-            'alter table a rename column x to y;',
-            `create or replace function f() returns void language plpgsql as $$ begin create index on b (id); end $$;`,
-        ]);
-        expect(['a', 'b', 'c', 'd'].map(t => schema.get(t).uncertain)).toEqual([true, true, true, true]);
-    });
-    it('treats an OR or an unreadable predicate as unknown', () => {
-        const schema = replayMigrations([
-            'create table t (a int, b int);',
-            `create index t_or on t (a) where a = 1 or b = 2;`,
-            `create index t_fn on t (a) where coalesce(b, 0) > 0;`,
-        ]);
-        expect(schema.get('t').indexes.map(i => i.predicate)).toEqual([[{ kind: 'unknown' }], [{ kind: 'unknown' }]]);
-    });
-    it('keeps SELECT and ALL policies as the columns they compare to the user', () => {
-        const schema = replayMigrations([
-            'create table subs (id text primary key, user_id uuid, status text);',
-            `create policy "own" on subs for select using (auth.uid() = user_id);`,
-            `create policy "writes" on subs for insert with check (auth.uid() = user_id);`,
-            `create policy "all" on subs to authenticated using (true);`,
-        ]);
-        expect(policyFilters(schema.get('subs'))).toEqual({ columns: ['user_id'], unknown: false });
-    });
-});
-describe('policyColumns', () => {
-    it('reads comparisons to the current user and gives up on anything else', () => {
-        expect(policyColumns('(select auth.uid()) = owner_id')).toEqual(['owner_id']);
-        expect(policyColumns('(owner_id = auth.uid()) or (editor_id = auth.uid())')).toEqual(['owner_id', 'editor_id']);
-        expect(policyColumns('true')).toEqual([]);
-        expect(policyColumns('exists (select 1 from members m where m.org_id = org_id)')).toBeNull();
-    });
-});

package/dist/gates/unindexed-reads/unindexed-reads.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/gates/unindexed-reads/unindexed-reads.test.js

@@ -1,90 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { UnindexedReadsGate } from './index.js';
-let repo;
-const write = (rel, body) => {
-    fs.mkdirSync(path.dirname(path.join(repo, rel)), { recursive: true });
-    fs.writeFileSync(path.join(repo, rel), body);
-};
-const run = (config = { enabled: true }) => new UnindexedReadsGate(config).run({ cwd: repo, patterns: ['src/**/*.ts'] });
-const TABLE = `create table orders (
-  id uuid primary key,
-  customer_id uuid,
-  status text not null,
-  placed_at timestamptz,
-  campaign_id uuid
-);
-create index orders_customer_idx on orders (customer_id, status, placed_at desc);
-create index orders_campaign_window_idx on orders (placed_at, id) where status = 'open' and campaign_id is not null;
-`;
-const WINDOW_READ = `
-export async function openOrders(db: Db, since: string, until: string) {
-  return db
-    .from('orders')
-    .select('id, placed_at')
-    .eq('status', 'open')
-    .not('customer_id', 'is', null)
-    .gt('placed_at', since)
-    .lte('placed_at', until)
-    .order('placed_at')
-    .order('id');
-}
-`;
-beforeEach(() => { repo = fs.mkdtempSync(path.join(os.tmpdir(), 'unindexed-')); });
-afterEach(() => fs.rmSync(repo, { recursive: true, force: true }));
-describe('UnindexedReadsGate', () => {
-    it('flags a window read whose only candidate index is partial on a filter the read does not have', async () => {
-        write('supabase/migrations/20260101000000_orders.sql', TABLE);
-        write('src/orders.ts', WINDOW_READ);
-        const failures = await run();
-        expect(failures).toHaveLength(1);
-        expect(failures[0]).toMatchObject({ id: 'unindexed-reads', files: ['src/orders.ts'], line: 4 });
-        expect(failures[0].details).toContain('`orders`');
-        expect(failures[0].details).toContain('`placed_at`');
-    });
-    it('is silent once a later migration adds an index that serves the read', async () => {
-        write('supabase/migrations/20260101000000_orders.sql', TABLE);
-        write('supabase/migrations/20260102000000_orders_open.sql', `create index concurrently orders_open_window_idx on public.orders (placed_at, id) where status = 'open' and customer_id is not null;`);
-        write('src/orders.ts', WINDOW_READ);
-        expect(await run()).toEqual([]);
-    });
-    it('is silent for a primary-key lookup, a table outside the migrations, and an uncertain table', async () => {
-        write('db/migrations/001_orders.sql', TABLE + 'create table notes (id int, body text);\nalter table notes rename column body to text;\n');
-        write('src/reads.ts', `
-          db.from('orders').select('*').eq('id', id);
-          db.from('auth_users').select('*').eq('email', email);
-          db.from('notes').select('*').eq('text', q);
-        `);
-        expect(await run()).toEqual([]);
-    });
-    it('is silent unless enabled, and for a read that narrows nothing', async () => {
-        write('supabase/migrations/20260101000000_orders.sql', TABLE);
-        write('src/orders.ts', WINDOW_READ + `\ndb.from('orders').select('*').limit(10);\n`);
-        expect(await run({ enabled: false })).toEqual([]);
-        expect(await new UnindexedReadsGate({ enabled: true }).run({ cwd: repo, patterns: ['src/**/*.ts'] })).toHaveLength(1);
-    });
-    it('needs every migration set that defines the table to lack a serving index', async () => {
-        write('apps/a/supabase/migrations/1_orders.sql', TABLE);
-        write('apps/b/supabase/migrations/1_orders.sql', TABLE + `create index orders_status_idx on orders (status);`);
-        write('src/orders.ts', WINDOW_READ);
-        expect(await run()).toEqual([]);
-    });
-    it('counts a row-level policy as a filter: names its column, and is silent once that column is indexed', async () => {
-        const subs = `create table subs (id text primary key, user_id uuid not null, status text);
-create policy "own subs" on subs for select using (auth.uid() = user_id);`;
-        write('supabase/migrations/1_subs.sql', subs);
-        write('src/subs.ts', `export const active = (db: Db) => db.from('subs').select('*').in('status', ['active']).maybeSingle();\n`);
-        const [finding] = await run();
-        expect(finding.details).toContain('`user_id`');
-        write('supabase/migrations/2_subs_user.sql', 'create index subs_user_idx on subs (user_id);');
-        expect(await run()).toEqual([]);
-    });
-    it('is silent for a table whose policy it cannot read', async () => {
-        write('supabase/migrations/1_docs.sql', `create table docs (id int primary key, org_id int, title text);
-create policy "members" on docs for select using (exists (select 1 from members m where m.org_id = docs.org_id));`);
-        write('src/docs.ts', `db.from('docs').select('*').eq('title', t);\n`);
-        expect(await run()).toEqual([]);
-    });
-});

package/dist/hooks/checker.test.d.ts

@@ -1 +0,0 @@
-export {};