From e020fdd76ca86e4f5fc30e685d342cd358c24fb8 Mon Sep 17 00:00:00 2001 From: Daniel Hritcu <134442484+dhritcu@users.noreply.github.com> Date: Fri, 31 Jul 2026 13:10:01 -0400 Subject: [PATCH 1/4] feat: add PostgreSQL indexing support --- CHANGELOG.md | 3 + README.md | 3 +- __tests__/postgres-extraction.test.ts | 191 +++++ __tests__/postgres-grammar-wiring.test.ts | 48 ++ __tests__/postgres-name-matcher.test.ts | 318 ++++++++ package.json | 2 +- src/extraction/extraction-version.ts | 2 +- src/extraction/grammars.ts | 12 + src/extraction/languages/index.ts | 2 + src/extraction/languages/postgres.ts | 713 ++++++++++++++++++ .../wasm/tree-sitter-postgres.LICENSE | 25 + src/extraction/wasm/tree-sitter-postgres.wasm | Bin 0 -> 14853663 bytes src/resolution/name-matcher.ts | 79 ++ src/types.ts | 1 + 14 files changed, 1396 insertions(+), 3 deletions(-) create mode 100644 __tests__/postgres-extraction.test.ts create mode 100644 __tests__/postgres-grammar-wiring.test.ts create mode 100644 __tests__/postgres-name-matcher.test.ts create mode 100644 src/extraction/languages/postgres.ts create mode 100644 src/extraction/wasm/tree-sitter-postgres.LICENSE create mode 100644 src/extraction/wasm/tree-sitter-postgres.wasm diff --git a/CHANGELOG.md b/CHANGELOG.md index d2ae567d0..c65e65b53 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -9,6 +9,9 @@ and adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). ## [Unreleased] +### New Features + +- PostgreSQL projects can now index `.sql`, `.psql`, and `.pgsql` files, including schemas, tables and their `CREATE TABLE` columns, views, routines, types, triggers, policies, indexes, sequences, extensions, and their common table, foreign-key, trigger, and routine dependencies; columns added later by `ALTER TABLE`, and string-literal routine bodies including dollar-quoted PL/pgSQL, remain opaque for now. ## [1.5.0] - 2026-07-21 diff --git a/README.md b/README.md index dccebd3e4..1d0549330 100644 --- a/README.md +++ b/README.md @@ -273,7 +273,7 @@ CodeGraph's parsing engine is a **native Rust kernel**: 20 languages — TypeScr | **Full-Text Search** | Find code by name instantly across your entire codebase, powered by FTS5 | | **Impact Analysis** | Trace callers, callees, and the full impact radius of any symbol before making changes | | **Always Fresh** | File watcher uses native OS events (FSEvents/inotify/ReadDirectoryChangesW) with debounced auto-sync — the graph stays current as you code, zero config | -| **20+ Languages** | TypeScript, JavaScript, ArkTS, Python, Go, Rust, Java, C#, VB.NET, PHP, Ruby, C, C++, CUDA, Objective-C, Metal, Swift, Kotlin, Scala, Dart, Lua, Luau, R, Nix, Erlang, CFML, COBOL, Solidity, Terraform/OpenTofu, Svelte, Vue, Astro, Liquid, Pascal/Delphi | +| **20+ Languages** | TypeScript, JavaScript, ArkTS, Python, Go, Rust, Java, C#, VB.NET, PHP, Ruby, C, C++, CUDA, Objective-C, Metal, Swift, Kotlin, Scala, Dart, Lua, Luau, R, Nix, Erlang, CFML, COBOL, Solidity, Terraform/OpenTofu, PostgreSQL, Svelte, Vue, Astro, Liquid, Pascal/Delphi | | **Framework-aware Routes** | Recognizes web-framework routing files and links URL patterns to their handlers across 17 frameworks | | **Mixed iOS / React Native / Expo** | Closes cross-language flows that static parsing misses: Swift ↔ ObjC bridging, React Native legacy bridge + TurboModules + Fabric view components, native → JS event emitters, Expo Modules | | **100% Local** | No data leaves your machine. No API keys. No external services. SQLite database only | @@ -794,6 +794,7 @@ is written): | Erlang | `.erl`, `.hrl`, `.escript`, `.app.src`, `.app` | Full support (functions with multi-clause/multi-arity grouping, `-spec` signatures, records with fields, `-type`/`-opaque` aliases, `-define` macros, `-include`/`-include_lib`/`-import` edges, local and `mod:fn` remote call edges, `fun name/arity` references, `spawn`/`apply`/`proc_lib`/`timer`/`rpc` MFA-argument call edges, `gen_server:call/cast(?MODULE)` → own `handle_call`/`handle_cast` links, `-behaviour` links, `-export`-based visibility) | | Solidity | `.sol` | Full support (contracts, libraries, interfaces, structs, enums, modifiers, events, errors, state variables, `import`/`using` directives, `emit`/`revert` calls) | | Terraform / OpenTofu | `.tf`, `.tfvars`, `.tofu` | Full support (resources, data sources, modules, variables, outputs, providers incl. aliases, `locals`; `var.`/`local.`/`module.`/resource references with Terraform's per-directory scoping enforced; module calls bridged across the boundary — inputs to the child module's variables, `module.M.out` to the child's output, `source` to the module's files; cloudposse/atmos `remote-state` cross-component wiring when the component is statically named; `provider = aws.east` selections resolved up the module tree; `moved`/`import`/`removed`/`check` block references; `.tfvars` assignments linked to the variables they set) | +| PostgreSQL | `.sql`, `.psql`, `.pgsql` | Initial support (schemas, tables and their `CREATE TABLE` columns, views/materialized views, functions/procedures, enums/domains, triggers, policies, indexes, sequences, extensions, foreign keys, relation dependencies, and routine calls; columns added later by `ALTER TABLE`, and string-literal routine bodies including dollar-quoted PL/pgSQL, are not parsed yet) | | Nix | `.nix` | Full support (functions with simple/destructured/curried params, `let`/attrset bindings, `inherit`, `import ./path` file edges — `./dir` resolving through `default.nix` — plus NixOS module `imports = [ ./x.nix ]` lists and `callPackage ./pkg.nix` file edges; call edges; module-system option wiring — a config write like `launchd.user.agents.x = { ... }` links to the module declaring `options.launchd.user.agents`, so option flows trace across modules) | ## Measured cross-file coverage diff --git a/__tests__/postgres-extraction.test.ts b/__tests__/postgres-extraction.test.ts new file mode 100644 index 000000000..c7f00c9c2 --- /dev/null +++ b/__tests__/postgres-extraction.test.ts @@ -0,0 +1,191 @@ +import { beforeAll, describe, expect, it } from 'vitest'; +import * as fs from 'node:fs'; +import * as os from 'node:os'; +import * as path from 'node:path'; +import { CodeGraph } from '../src'; +import { extractFromSource } from '../src/extraction'; +import { initGrammars, loadGrammarsForLanguages } from '../src/extraction/grammars'; + +beforeAll(async () => { + await initGrammars(); + await loadGrammarsForLanguages(['postgres']); +}); + +function extract(source: string) { + return extractFromSource('db/schema.sql', source, 'postgres'); +} + +describe('PostgreSQL extraction', () => { + it('extracts database objects and columns with generic CodeGraph kinds', () => { + const result = extract([ + 'CREATE SCHEMA app;', + "CREATE TYPE app.status AS ENUM ('active', 'disabled');", + 'CREATE TYPE app.coordinate AS (x integer, y integer);', + "CREATE DOMAIN app.email AS text CHECK (VALUE <> '');", + 'CREATE TABLE app.users (id bigint PRIMARY KEY, email app.email);', + 'CREATE FOREIGN TABLE app.remote_events (id bigint) SERVER analytics;', + 'CREATE TABLE app.user_copy (id, email) AS SELECT id, email FROM app.users;', + 'CREATE VIEW app.active_users (id, email) AS SELECT id, email FROM app.users;', + 'CREATE MATERIALIZED VIEW app.user_rollup AS SELECT count(*) FROM app.users;', + 'CREATE FUNCTION app.touch_user(p_id bigint) RETURNS void LANGUAGE sql AS \'SELECT 1\';', + 'CREATE PROCEDURE app.refresh_users() LANGUAGE sql AS \'SELECT 1\';', + 'CREATE TRIGGER users_touch AFTER UPDATE ON app.users EXECUTE FUNCTION app.touch_user();', + 'CREATE POLICY users_read ON app.users USING (true);', + 'CREATE INDEX users_email_idx ON app.users(email);', + 'CREATE SEQUENCE app.event_id_seq;', + 'CREATE EXTENSION IF NOT EXISTS pgcrypto;', + ].join('\n')); + + expect(result.errors).toEqual([]); + + const byQualifiedName = new Map(result.nodes.map((node) => [node.qualifiedName, node])); + expect(byQualifiedName.get('app')?.kind).toBe('namespace'); + expect(byQualifiedName.get('app.status')?.kind).toBe('enum'); + expect(byQualifiedName.get('app.status.active')?.kind).toBe('enum_member'); + expect(byQualifiedName.get('app.coordinate')?.kind).toBe('type_alias'); + expect(byQualifiedName.get('app.email')?.decorators).toContain('postgres:domain'); + + expect(byQualifiedName.get('app.users')?.kind).toBe('struct'); + expect(byQualifiedName.get('app.users.id')?.kind).toBe('field'); + expect(byQualifiedName.get('app.remote_events')?.decorators).toContain('postgres:foreign-table'); + expect(byQualifiedName.get('app.user_copy')?.decorators).toContain('postgres:table'); + expect(byQualifiedName.get('app.user_copy.email')?.kind).toBe('field'); + expect(byQualifiedName.get('app.active_users')?.decorators).toContain('postgres:view'); + expect(byQualifiedName.get('app.active_users.id')?.kind).toBe('field'); + expect(byQualifiedName.get('app.user_rollup')?.decorators).toContain('postgres:materialized-view'); + + expect(byQualifiedName.get('app.touch_user')?.kind).toBe('function'); + expect(byQualifiedName.get('app.refresh_users')?.decorators).toContain('postgres:procedure'); + expect(byQualifiedName.get('app.users.users_touch')?.decorators).toContain('postgres:trigger'); + expect(byQualifiedName.get('app.users.users_read')?.decorators).toContain('postgres:policy'); + expect(byQualifiedName.get('app.users_email_idx')?.decorators).toContain('postgres:index'); + expect(byQualifiedName.get('app.event_id_seq')?.decorators).toContain('postgres:sequence'); + expect(byQualifiedName.get('pgcrypto')?.decorators).toContain('postgres:extension'); + }); + + it('emits and de-duplicates relation and routine references while ignoring CTE aliases', () => { + const result = extract([ + 'CREATE VIEW app.dashboard AS', + 'WITH recent AS (', + ' SELECT * FROM audit.events', + ')', + 'SELECT *', + 'FROM recent', + 'JOIN app.users u ON true', + 'JOIN app.users u2 ON true', + 'WHERE app.can_view(u.id) AND app.can_view(u2.id);', + ].join('\n')); + + const view = result.nodes.find((node) => node.qualifiedName === 'app.dashboard'); + expect(view).toBeTruthy(); + + const refs = result.unresolvedReferences.filter((ref) => ref.fromNodeId === view!.id); + expect(refs.map((ref) => `${ref.referenceKind}:${ref.referenceName}`).sort()).toEqual([ + 'calls:app.can_view', + 'references:app.users', + 'references:audit.events', + ]); + expect(refs.some((ref) => ref.referenceName === 'recent')).toBe(false); + }); + + it('does not leak a nested query CTE alias into the outer query scope', () => { + const result = extract([ + 'SELECT * FROM recent', + 'WHERE EXISTS (', + ' WITH recent AS (SELECT * FROM audit.events)', + ' SELECT * FROM recent', + ');', + ].join('\n')); + + const file = result.nodes.find((node) => node.kind === 'file')!; + const refs = result.unresolvedReferences + .filter((ref) => ref.fromNodeId === file.id && ref.referenceKind === 'references') + .map((ref) => ref.referenceName) + .sort(); + expect(refs).toEqual(['audit.events', 'recent']); + }); + + it('canonicalizes quoted and unquoted identifiers and captures ALTER TABLE foreign keys', () => { + const result = extract([ + 'CREATE TABLE "App"."Users" ("ID" bigint);', + 'CREATE TABLE PUBLIC.TEAMS (ID bigint);', + 'ALTER TABLE "App"."Users"', + ' ADD CONSTRAINT users_team_fk FOREIGN KEY ("ID") REFERENCES PUBLIC.TEAMS(ID);', + 'SELECT * FROM "App"."Users";', + ].join('\n')); + + expect(result.nodes.some((node) => node.qualifiedName === 'App.Users')).toBe(true); + expect(result.nodes.some((node) => node.qualifiedName === 'App.Users.ID')).toBe(true); + expect(result.nodes.some((node) => node.qualifiedName === 'public.teams')).toBe(true); + + const file = result.nodes.find((node) => node.kind === 'file')!; + const fileRefs = result.unresolvedReferences + .filter((ref) => ref.fromNodeId === file.id && ref.referenceKind === 'references') + .map((ref) => ref.referenceName) + .sort(); + expect(fileRefs).toEqual(['App.Users', 'public.teams']); + }); + + it('does not create file-scoped fields for ALTER TABLE ADD COLUMN', () => { + const result = extract([ + 'CREATE TABLE app.users (id bigint);', + 'ALTER TABLE app.users ADD COLUMN email text;', + ].join('\n')); + + const fields = result.nodes.filter((node) => node.kind === 'field'); + expect(fields.map((node) => node.qualifiedName)).toEqual(['app.users.id']); + expect(result.unresolvedReferences.some( + (ref) => ref.referenceKind === 'references' && ref.referenceName === 'app.users' + )).toBe(true); + }); + + it('keeps dollar-quoted PL/pgSQL bodies opaque in the PostgreSQL-only phase', () => { + const result = extract([ + 'CREATE FUNCTION app.run_job() RETURNS void', + 'LANGUAGE plpgsql AS $$', + 'BEGIN', + ' PERFORM app.hidden_call();', + ' INSERT INTO app.hidden_table VALUES (1);', + 'END', + '$$;', + ].join('\n')); + + expect(result.nodes.some((node) => node.qualifiedName === 'app.run_job')).toBe(true); + expect(result.unresolvedReferences.some((ref) => ref.referenceName === 'app.hidden_call')).toBe(false); + expect(result.unresolvedReferences.some((ref) => ref.referenceName === 'app.hidden_table')).toBe(false); + }); + + it('indexes and resolves PostgreSQL dependencies through the full CodeGraph pipeline', async () => { + const projectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-postgres-')); + fs.writeFileSync( + path.join(projectDir, '001_accounts.sql'), + 'CREATE TABLE app.accounts (id bigint PRIMARY KEY, active boolean);\n' + ); + fs.writeFileSync( + path.join(projectDir, '002_active_accounts.sql'), + 'CREATE VIEW app.active_accounts AS SELECT * FROM app.accounts WHERE active;\n' + ); + + const graph = CodeGraph.initSync(projectDir); + try { + await graph.indexAll(); + + const table = graph.getNodesByName('accounts').find( + (node) => node.qualifiedName === 'app.accounts' + ); + const view = graph.getNodesByName('active_accounts').find( + (node) => node.qualifiedName === 'app.active_accounts' + ); + expect(table).toMatchObject({ kind: 'struct', language: 'postgres' }); + expect(view).toMatchObject({ kind: 'struct', language: 'postgres' }); + + const incoming = graph.getIncomingEdges(table!.id); + expect(incoming.some( + (edge) => edge.source === view!.id && edge.kind === 'references' + )).toBe(true); + } finally { + graph.destroy(); + fs.rmSync(projectDir, { recursive: true, force: true }); + } + }); +}); diff --git a/__tests__/postgres-grammar-wiring.test.ts b/__tests__/postgres-grammar-wiring.test.ts new file mode 100644 index 000000000..5c43440aa --- /dev/null +++ b/__tests__/postgres-grammar-wiring.test.ts @@ -0,0 +1,48 @@ +import { beforeAll, describe, expect, it } from 'vitest'; +import { createHash } from 'node:crypto'; +import { + detectLanguage, + getParser, + getSupportedLanguages, + initGrammars, + isLanguageSupported, + isSourceFile, + loadGrammarsForLanguages, + readGrammarWasmBytes, +} from '../src/extraction/grammars'; + +describe('PostgreSQL grammar wiring', () => { + beforeAll(async () => { + await initGrammars(); + await loadGrammarsForLanguages(['postgres']); + }); + + it('recognizes SQL files as PostgreSQL source', () => { + expect(detectLanguage('migrations/001_create_users.sql')).toBe('postgres'); + expect(detectLanguage('migrations/001_create_users.SQL')).toBe('postgres'); + expect(detectLanguage('scripts/maintenance.psql')).toBe('postgres'); + expect(detectLanguage('scripts/maintenance.pgsql')).toBe('postgres'); + expect(isSourceFile('migrations/001_create_users.sql')).toBe(true); + expect(isSourceFile('scripts/maintenance.psql')).toBe(true); + expect(isSourceFile('scripts/maintenance.pgsql')).toBe(true); + expect(isLanguageSupported('postgres')).toBe(true); + expect(getSupportedLanguages()).toContain('postgres'); + }); + + it('ships and loads the vendored PostgreSQL grammar', async () => { + const grammarBytes = await readGrammarWasmBytes(['postgres']); + expect(grammarBytes.postgres?.byteLength).toBeGreaterThan(0); + expect(createHash('sha256').update(grammarBytes.postgres!).digest('hex')).toBe( + '084883e58414c407dfac6f37f0facc983afdfe8103e17f5fd2ca138b79a22b92' + ); + + const parser = getParser('postgres'); + expect(parser).not.toBeNull(); + + const tree = parser!.parse( + 'CREATE TABLE public.users (id bigint PRIMARY KEY); SELECT id FROM public.users;' + ); + expect(tree!.rootNode.hasError).toBe(false); + tree!.delete(); + }); +}); diff --git a/__tests__/postgres-name-matcher.test.ts b/__tests__/postgres-name-matcher.test.ts new file mode 100644 index 000000000..e354a2283 --- /dev/null +++ b/__tests__/postgres-name-matcher.test.ts @@ -0,0 +1,318 @@ +/** + * PostgreSQL reference-resolution precision. + * + * Migration repositories commonly repeat an object across historical files + * and reuse simple names in different schemas. These tests pin that PostgreSQL + * references never inherit the generic matcher's suffix, fuzzy, or + * path-proximity guesses. + */ +import { describe, expect, it } from 'vitest'; +import { matchReference } from '../src/resolution/name-matcher'; +import type { Language, Node, NodeKind } from '../src/types'; +import type { ResolutionContext, UnresolvedRef } from '../src/resolution/types'; + +interface NodeOptions { + id: string; + name: string; + qualifiedName?: string; + filePath: string; + kind?: NodeKind; + language?: Language; + decorators?: string[]; +} + +function makeNode(options: NodeOptions): Node { + return { + id: options.id, + name: options.name, + qualifiedName: options.qualifiedName ?? options.name, + filePath: options.filePath, + kind: options.kind ?? 'struct', + language: options.language ?? 'postgres', + decorators: options.decorators, + startLine: 1, + endLine: 1, + startColumn: 0, + endColumn: 1, + updatedAt: 0, + }; +} + +function makeRef( + referenceName: string, + filePath = 'migrations/003_consumer.sql', + referenceKind: UnresolvedRef['referenceKind'] = 'references' +): UnresolvedRef { + return { + fromNodeId: `from:${filePath}`, + referenceName, + referenceKind, + line: 10, + column: 2, + filePath, + language: 'postgres', + }; +} + +function contextFor(nodes: Node[]): ResolutionContext { + return { + getNodesInFile: (filePath) => nodes.filter((node) => node.filePath === filePath), + getNodesByName: (name) => nodes.filter((node) => node.name === name), + getNodesByQualifiedName: (qualifiedName) => + nodes.filter((node) => node.qualifiedName === qualifiedName), + getNodesByKind: (kind) => nodes.filter((node) => node.kind === kind), + fileExists: (filePath) => nodes.some((node) => node.filePath === filePath), + readFile: () => null, + getProjectRoot: () => '/project', + getAllFiles: () => [...new Set(nodes.map((node) => node.filePath))], + getNodesByLowerName: (lowerName) => + nodes.filter((node) => node.name.toLowerCase() === lowerName), + getImportMappings: () => [], + }; +} + +describe('PostgreSQL qualified-name resolution', () => { + it.each(['public.users', 'public::users'])( + 'matches only the exact canonical qualified name (%s)', + (qualifiedName) => { + const publicUsers = makeNode({ + id: 'public-users', + name: 'users', + qualifiedName, + filePath: 'migrations/001_public.sql', + }); + const authUsers = makeNode({ + id: 'auth-users', + name: 'users', + qualifiedName: qualifiedName.replace('public', 'auth'), + filePath: 'migrations/001_auth.sql', + }); + + expect(matchReference(makeRef(qualifiedName), contextFor([publicUsers, authUsers]))) + .toMatchObject({ targetNodeId: publicUsers.id, resolvedBy: 'qualified-name' }); + } + ); + + it('does not use a qualified-name suffix match', () => { + const nested = makeNode({ + id: 'nested-users', + name: 'users', + qualifiedName: 'tenant::public::users', + filePath: 'migrations/001.sql', + }); + + expect(matchReference(makeRef('public::users'), contextFor([nested]))).toBeNull(); + }); + + it('prefers one exact same-file revision over duplicate historical definitions', () => { + const historical = makeNode({ + id: 'users-v1', + name: 'users', + qualifiedName: 'public::users', + filePath: 'migrations/001_create_users.sql', + }); + const local = makeNode({ + id: 'users-v2', + name: 'users', + qualifiedName: 'public::users', + filePath: 'migrations/003_consumer.sql', + }); + + expect(matchReference(makeRef('public::users'), contextFor([historical, local]))) + .toMatchObject({ targetNodeId: local.id }); + }); + + it('leaves duplicate exact definitions unresolved when none is in the reference file', () => { + const nodes = [ + makeNode({ + id: 'users-v1', + name: 'users', + qualifiedName: 'public::users', + filePath: 'migrations/001_create_users.sql', + }), + makeNode({ + id: 'users-v2', + name: 'users', + qualifiedName: 'public::users', + filePath: 'migrations/002_replace_users.sql', + }), + ]; + + expect(matchReference(makeRef('public::users'), contextFor(nodes))).toBeNull(); + }); + + it('leaves multiple same-file overloads/revisions unresolved', () => { + const nodes = [ + makeNode({ + id: 'calculate-int', + name: 'calculate', + qualifiedName: 'public::calculate', + filePath: 'migrations/003_consumer.sql', + kind: 'function', + decorators: ['postgres:function'], + }), + makeNode({ + id: 'calculate-text', + name: 'calculate', + qualifiedName: 'public::calculate', + filePath: 'migrations/003_consumer.sql', + kind: 'function', + decorators: ['postgres:function'], + }), + ]; + + expect(matchReference(makeRef('public::calculate', undefined, 'calls'), contextFor(nodes))) + .toBeNull(); + }); +}); + +describe('PostgreSQL unqualified-name resolution', () => { + it('prefers one same-file object over same-named objects in other schemas/files', () => { + const local = makeNode({ + id: 'local-users', + name: 'users', + qualifiedName: 'public::users', + filePath: 'migrations/003_consumer.sql', + }); + const other = makeNode({ + id: 'auth-users', + name: 'users', + qualifiedName: 'auth::users', + filePath: 'migrations/001_auth.sql', + }); + + expect(matchReference(makeRef('users'), contextFor([other, local]))) + .toMatchObject({ targetNodeId: local.id, resolvedBy: 'exact-match' }); + }); + + it('resolves one globally unique object', () => { + const users = makeNode({ + id: 'users', + name: 'users', + qualifiedName: 'public::users', + filePath: 'migrations/001.sql', + }); + + expect(matchReference(makeRef('users'), contextFor([users]))) + .toMatchObject({ targetNodeId: users.id }); + }); + + it('does not pick a path-proximate object when an unqualified name is ambiguous', () => { + const nodes = [ + makeNode({ + id: 'near-users', + name: 'users', + qualifiedName: 'public::users', + filePath: 'migrations/002_near.sql', + }), + makeNode({ + id: 'far-users', + name: 'users', + qualifiedName: 'auth::users', + filePath: 'schemas/auth/001.sql', + }), + ]; + + expect(matchReference(makeRef('users'), contextFor(nodes))).toBeNull(); + }); + + it('does not fuzzy-match case variants', () => { + const users = makeNode({ + id: 'users', + name: 'users', + filePath: 'migrations/001.sql', + }); + + expect(matchReference(makeRef('Users'), contextFor([users]))).toBeNull(); + }); +}); + +describe('PostgreSQL target-kind precision', () => { + it('resolves calls only to decorated routines, never a same-named trigger', () => { + const relation = makeNode({ + id: 'relation-refresh', + name: 'refresh_cache', + filePath: 'migrations/001.sql', + kind: 'struct', + }); + const routine = makeNode({ + id: 'routine-refresh', + name: 'refresh_cache', + filePath: 'migrations/002.sql', + kind: 'function', + decorators: ['postgres:function'], + }); + const trigger = makeNode({ + id: 'trigger-refresh', + name: 'refresh_cache', + qualifiedName: 'app.cache.refresh_cache', + filePath: 'migrations/003_consumer.sql', + kind: 'function', + decorators: ['postgres:trigger'], + }); + + expect( + matchReference( + makeRef('refresh_cache', undefined, 'calls'), + contextFor([relation, trigger, routine]) + ) + ) + .toMatchObject({ targetNodeId: routine.id }); + }); + + it('resolves relation references only to struct nodes', () => { + const file = makeNode({ + id: 'file-users', + name: 'users', + filePath: 'users.sql', + kind: 'file', + }); + const imported = makeNode({ + id: 'import-users', + name: 'users', + filePath: 'imports.sql', + kind: 'import', + }); + const column = makeNode({ + id: 'column-users', + name: 'users', + filePath: 'columns.sql', + kind: 'field', + }); + const policy = makeNode({ + id: 'policy-users', + name: 'users', + filePath: 'policies.sql', + kind: 'constant', + }); + const enumMember = makeNode({ + id: 'enum-member-users', + name: 'users', + qualifiedName: 'app.object_kind.users', + filePath: 'types.sql', + kind: 'enum_member', + }); + + expect( + matchReference(makeRef('users'), contextFor([file, imported, column, policy, enumMember])) + ).toBeNull(); + }); + + it('ignores same-named symbols from other languages', () => { + const typescript = makeNode({ + id: 'ts-users', + name: 'users', + filePath: 'src/users.ts', + kind: 'constant', + language: 'typescript', + }); + const postgres = makeNode({ + id: 'pg-users', + name: 'users', + filePath: 'migrations/001.sql', + }); + + expect(matchReference(makeRef('users'), contextFor([typescript, postgres]))) + .toMatchObject({ targetNodeId: postgres.id }); + }); +}); diff --git a/package.json b/package.json index e661e803d..7f75b25c3 100644 --- a/package.json +++ b/package.json @@ -19,7 +19,7 @@ "scripts": { "build": "tsc && npm run copy-assets && node -e \"require('fs').chmodSync('dist/bin/codegraph.js', 0o755)\"", "preuninstall": "node dist/bin/uninstall.js", - "copy-assets": "node -e \"const fs=require('fs');fs.mkdirSync('dist/db',{recursive:true});fs.copyFileSync('src/db/schema.sql','dist/db/schema.sql');fs.mkdirSync('dist/extraction/wasm',{recursive:true});fs.readdirSync('src/extraction/wasm').filter(f=>f.endsWith('.wasm')).forEach(f=>fs.copyFileSync('src/extraction/wasm/'+f,'dist/extraction/wasm/'+f))\"", + "copy-assets": "node -e \"const fs=require('fs');fs.mkdirSync('dist/db',{recursive:true});fs.copyFileSync('src/db/schema.sql','dist/db/schema.sql');fs.mkdirSync('dist/extraction/wasm',{recursive:true});fs.readdirSync('src/extraction/wasm').filter(f=>f.endsWith('.wasm')||f==='tree-sitter-postgres.LICENSE').forEach(f=>fs.copyFileSync('src/extraction/wasm/'+f,'dist/extraction/wasm/'+f))\"", "dev": "tsc --watch", "build:kernel": "bash scripts/build-kernel.sh", "cli": "npm run build && node dist/bin/codegraph.js", diff --git a/src/extraction/extraction-version.ts b/src/extraction/extraction-version.ts index 618a1b1c3..07ccbb964 100644 --- a/src/extraction/extraction-version.ts +++ b/src/extraction/extraction-version.ts @@ -21,4 +21,4 @@ * turns the re-index hint into noise — keep it honest (see CLAUDE.md, "Honesty * in the product is load-bearing"). */ -export const EXTRACTION_VERSION = 24; +export const EXTRACTION_VERSION = 25; diff --git a/src/extraction/grammars.ts b/src/extraction/grammars.ts index d4127631d..dff4fe210 100644 --- a/src/extraction/grammars.ts +++ b/src/extraction/grammars.ts @@ -50,6 +50,7 @@ const WASM_GRAMMAR_FILES: Record = { terraform: 'tree-sitter-terraform.wasm', arkts: 'tree-sitter-arkts.wasm', nix: 'tree-sitter-nix.wasm', + postgres: 'tree-sitter-postgres.wasm', }; /** @@ -170,6 +171,11 @@ export const EXTENSION_MAP: Record = { '.tf': 'terraform', '.tfvars': 'terraform', '.tofu': 'terraform', + // PostgreSQL SQL and migration files. Projects using other PostgreSQL file + // extensions can opt into the grammar through a codegraph.json override. + '.sql': 'postgres', + '.psql': 'postgres', + '.pgsql': 'postgres', }; /** @@ -287,10 +293,15 @@ export async function initGrammars(): Promise { * (parser.c sha-matched against the crates.io tarball). * The kernel-grammar-parity test asserts this alignment; bump the crate and * the vendored wasm together. + * + * PostgreSQL: gmr/tree-sitter-postgres v1.2.4 (BSD-3-Clause), using the + * release's prebuilt ABI-15 tree-sitter-postgres.wasm. The artifact's SHA-256 + * is 084883e58414c407dfac6f37f0facc983afdfe8103e17f5fd2ca138b79a22b92. */ const VENDORED_WASM_LANGS: ReadonlySet = new Set([ 'pascal', 'scala', 'lua', 'luau', 'csharp', 'r', 'cfml', 'cfscript', 'cfquery', 'cobol', 'vbnet', 'erlang', 'terraform', 'arkts', 'nix', + 'postgres', 'typescript', 'tsx', 'javascript', 'jsx', 'java', 'python', 'go', // R7a (C/C++ kernel port prep): tree-sitter-c v0.24.2 (b780e47) + // tree-sitter-cpp v0.23.4 (f41e1a0), parser.c/scanner.c sha-matched against @@ -654,6 +665,7 @@ export function getLanguageDisplayName(language: Language): string { vbnet: 'Visual Basic .NET', erlang: 'Erlang', terraform: 'Terraform', + postgres: 'PostgreSQL', arkts: 'ArkTS', unknown: 'Unknown', }; diff --git a/src/extraction/languages/index.ts b/src/extraction/languages/index.ts index 6b760b01d..f0cd3e1ff 100644 --- a/src/extraction/languages/index.ts +++ b/src/extraction/languages/index.ts @@ -36,6 +36,7 @@ import { solidityExtractor } from './solidity'; import { terraformExtractor } from './terraform'; import { arktsExtractor } from './arkts'; import { nixExtractor } from './nix'; +import { postgresExtractor } from './postgres'; export const EXTRACTORS: Partial> = { typescript: typescriptExtractor, @@ -69,4 +70,5 @@ export const EXTRACTORS: Partial> = { terraform: terraformExtractor, arkts: arktsExtractor, nix: nixExtractor, + postgres: postgresExtractor, }; diff --git a/src/extraction/languages/postgres.ts b/src/extraction/languages/postgres.ts new file mode 100644 index 000000000..d32bb46d8 --- /dev/null +++ b/src/extraction/languages/postgres.ts @@ -0,0 +1,713 @@ +import type { Node as SyntaxNode } from 'web-tree-sitter'; +import type { Node, NodeKind } from '../../types'; +import { getNodeText } from '../tree-sitter-helpers'; +import type { ExtractorContext, LanguageExtractor } from '../tree-sitter-types'; + +/** + * PostgreSQL extractor for gmr/tree-sitter-postgres. + * + * The generated PostgreSQL grammar intentionally has no field map, so this + * extractor cannot use the generic `nameField` / `bodyField` dispatcher. It + * recognizes statement shapes explicitly and keeps SQL's own dotted names as + * qualified names (`schema.object`). Generic CodeGraph node kinds are reused; + * the precise database-object kind is retained as a `postgres:*` decorator. + * + * String-literal routine bodies are opaque leaves in the PostgreSQL grammar. + * Top-level SQL and SQL expressions are therefore indexed here, while nested + * SQL/PL/pgSQL extraction requires an injected body grammar and is deliberately + * left for a follow-up. + */ + +interface SqlName { + parts: string[]; + qualified: string; + simple: string; +} + +type ReferenceKind = 'references' | 'calls'; + +const NAME_SEGMENT_TYPES = new Set(['ColId', 'ColLabel', 'type_function_name']); + +// Avoid filling unresolved_refs with ubiquitous PostgreSQL/SQL built-ins. A +// schema-qualified spelling is never filtered because it may be user-defined. +const BUILTIN_ROUTINES = new Set([ + 'any', + 'array_length', + 'array_remove', + 'array_agg', + 'avg', + 'bool_or', + 'cast', + 'coalesce', + 'concat', + 'count', + 'current_date', + 'current_setting', + 'current_time', + 'current_timestamp', + 'date_part', + 'date_trunc', + 'encode', + 'extract', + 'first_value', + 'gen_random_uuid', + 'greatest', + 'json_agg', + 'json_build_array', + 'json_build_object', + 'jsonb_agg', + 'jsonb_array_elements_text', + 'jsonb_array_length', + 'jsonb_build_array', + 'jsonb_build_object', + 'jsonb_set', + 'jsonb_strip_nulls', + 'jsonb_typeof', + 'least', + 'length', + 'lower', + 'max', + 'min', + 'nextval', + 'now', + 'nullif', + 'position', + 'round', + 'row_number', + 'row_to_json', + 'set_config', + 'split_part', + 'substring', + 'sum', + 'to_char', + 'to_date', + 'to_json', + 'to_jsonb', + 'trim', + 'unnest', + 'upper', +]); + +/** Per-extraction reference de-duplication. `ctx.nodes` is stable for a file. */ +const emittedReferenceKeys = new WeakMap>(); + +function children(node: SyntaxNode): SyntaxNode[] { + const result: SyntaxNode[] = []; + for (let i = 0; i < node.namedChildCount; i++) { + const child = node.namedChild(i); + if (child) result.push(child); + } + return result; +} + +function directChild(node: SyntaxNode, ...types: string[]): SyntaxNode | null { + for (let i = 0; i < node.namedChildCount; i++) { + const child = node.namedChild(i); + if (child && types.includes(child.type)) return child; + } + return null; +} + +function firstDescendant(node: SyntaxNode, ...types: string[]): SyntaxNode | null { + for (const child of children(node)) { + if (types.includes(child.type)) return child; + const nested = firstDescendant(child, ...types); + if (nested) return nested; + } + return null; +} + +function allDescendants(node: SyntaxNode, type: string): SyntaxNode[] { + const result: SyntaxNode[] = []; + const visit = (current: SyntaxNode): void => { + for (const child of children(current)) { + if (child.type === type) result.push(child); + visit(child); + } + }; + visit(node); + return result; +} + +function hasDirectChild(node: SyntaxNode, type: string): boolean { + return directChild(node, type) !== null; +} + +/** PostgreSQL folds unquoted identifiers to lower case; quoted names do not. */ +function canonicalSegment(node: SyntaxNode, source: string): string { + const raw = getNodeText(node, source).trim(); + if (raw.length >= 2 && raw.startsWith('"') && raw.endsWith('"')) { + return raw.slice(1, -1).replace(/""/g, '"'); + } + return raw.toLowerCase(); +} + +/** + * Read a grammar name wrapper (`qualified_name`, `func_name`, `any_name`, + * `name`, ...). Segment wrappers are used rather than identifier leaves so + * keyword-shaped legal identifiers (for example `source`) are retained. + */ +function readSqlName(node: SyntaxNode | null, source: string): SqlName | null { + if (!node) return null; + const parts: string[] = []; + + const visit = (current: SyntaxNode): void => { + if (NAME_SEGMENT_TYPES.has(current.type)) { + const part = canonicalSegment(current, source); + if (part) parts.push(part); + return; + } + if (current.type === 'identifier' || current.type === 'quoted_identifier') { + const part = canonicalSegment(current, source); + if (part) parts.push(part); + return; + } + for (const child of children(current)) visit(child); + }; + + visit(node); + if (parts.length === 0) return null; + return { + parts, + qualified: parts.join('.'), + simple: parts[parts.length - 1]!, + }; +} + +function nestedSchema(node: SyntaxNode, source: string): string | null { + let parent = node.parent; + while (parent) { + if (parent.type === 'CreateSchemaStmt') { + const nameNode = directChild(parent, 'ColId', 'opt_single_name'); + return readSqlName(nameNode, source)?.qualified ?? null; + } + parent = parent.parent; + } + return null; +} + +function objectName(node: SyntaxNode, nameNode: SyntaxNode | null, source: string): SqlName | null { + const name = readSqlName(nameNode, source); + if (!name || name.parts.length > 1 || node.type === 'CreateSchemaStmt') return name; + const schema = nestedSchema(node, source); + if (!schema) return name; + return { + parts: [schema, ...name.parts], + qualified: `${schema}.${name.qualified}`, + simple: name.simple, + }; +} + +function compactText(node: SyntaxNode, source: string, maxLength = 320): string { + const compact = getNodeText(node, source).replace(/\s+/g, ' ').trim(); + return compact.length <= maxLength ? compact : `${compact.slice(0, maxLength - 1)}…`; +} + +function currentScopeId(ctx: ExtractorContext): string | null { + return ctx.nodeStack[ctx.nodeStack.length - 1] ?? null; +} + +function currentScopeNode(ctx: ExtractorContext): Node | null { + const id = currentScopeId(ctx); + return id ? ctx.nodes.find((node) => node.id === id) ?? null : null; +} + +function currentScopeQualifiedName(ctx: ExtractorContext): string | null { + return currentScopeNode(ctx)?.qualifiedName ?? null; +} + +function addReference( + ctx: ExtractorContext, + fromNodeId: string, + target: SqlName, + kind: ReferenceKind, + positionNode: SyntaxNode +): void { + let keys = emittedReferenceKeys.get(ctx.nodes); + if (!keys) { + keys = new Set(); + emittedReferenceKeys.set(ctx.nodes, keys); + } + const key = `${fromNodeId}\u0000${kind}\u0000${target.qualified}`; + if (keys.has(key)) return; + keys.add(key); + + ctx.addUnresolvedReference({ + fromNodeId, + referenceName: target.qualified, + referenceKind: kind, + line: positionNode.startPosition.row + 1, + column: positionNode.startPosition.column, + }); +} + +function createDatabaseNode( + ctx: ExtractorContext, + node: SyntaxNode, + name: SqlName, + kind: NodeKind, + objectKind: string, + qualifiedName = name.qualified, + signature = compactText(node, ctx.source) +) { + return ctx.createNode(kind, name.simple, node, { + qualifiedName, + signature, + decorators: [`postgres:${objectKind}`], + isExported: true, + }); +} + +function walkChildren(node: SyntaxNode, ctx: ExtractorContext): void { + for (const child of children(node)) ctx.visitNode(child); +} + +function createColumn(ctx: ExtractorContext, node: SyntaxNode, nameNode: SyntaxNode): void { + const name = readSqlName(nameNode, ctx.source); + if (!name) return; + const parentQualified = currentScopeQualifiedName(ctx); + ctx.createNode('field', name.simple, node, { + qualifiedName: parentQualified ? `${parentQualified}.${name.simple}` : name.qualified, + signature: compactText(node, ctx.source, 200), + decorators: ['postgres:column'], + isExported: true, + }); +} + +function createExplicitColumns(container: SyntaxNode | null, ctx: ExtractorContext): void { + if (!container) return; + const columnList = directChild(container, 'opt_column_list', 'columnList'); + if (!columnList) return; + for (const column of allDescendants(columnList, 'columnElem')) { + const nameNode = directChild(column, 'ColId'); + if (nameNode) createColumn(ctx, column, nameNode); + } +} + +function createEnumMembers(node: SyntaxNode, ctx: ExtractorContext): void { + const values = directChild(node, 'opt_enum_val_list'); + if (!values) return; + const parentQualified = currentScopeQualifiedName(ctx); + for (const literal of allDescendants(values, 'string_literal')) { + const raw = getNodeText(literal, ctx.source); + const value = raw.startsWith("'") && raw.endsWith("'") + ? raw.slice(1, -1).replace(/''/g, "'") + : raw; + if (!value) continue; + ctx.createNode('enum_member', value, literal, { + qualifiedName: parentQualified ? `${parentQualified}.${value}` : value, + signature: raw, + decorators: ['postgres:enum-value'], + isExported: true, + }); + } +} + +function withCreatedScope( + ctx: ExtractorContext, + created: ReturnType, + body: () => void +): void { + if (!created) return; + ctx.pushScope(created.id); + try { + body(); + } finally { + ctx.popScope(); + } +} + +function createTableLike( + node: SyntaxNode, + ctx: ExtractorContext, + nameNode: SyntaxNode | null, + objectKind: string, + explicitColumnsContainer?: SyntaxNode | null +): boolean { + const name = objectName(node, nameNode, ctx.source); + if (!name) return true; + const created = createDatabaseNode(ctx, node, name, 'struct', objectKind); + withCreatedScope(ctx, created, () => { + createExplicitColumns(explicitColumnsContainer ?? node, ctx); + walkChildren(node, ctx); + }); + return true; +} + +function routineSignature(node: SyntaxNode, name: SqlName, source: string): string { + const args = directChild(node, 'func_args_with_defaults'); + const returns = directChild(node, 'func_return', 'table_func_column_list'); + const isProcedure = hasDirectChild(node, 'kw_procedure'); + const prefix = isProcedure ? 'CREATE PROCEDURE' : 'CREATE FUNCTION'; + const argsText = args ? compactText(args, source, 180) : '()'; + const returnText = returns ? ` RETURNS ${compactText(returns, source, 100)}` : ''; + return `${prefix} ${name.qualified}${argsText}${returnText}`; +} + +function createRoutine(node: SyntaxNode, ctx: ExtractorContext): boolean { + const name = objectName(node, directChild(node, 'func_name'), ctx.source); + if (!name) return true; + const objectKind = hasDirectChild(node, 'kw_procedure') ? 'procedure' : 'function'; + const created = createDatabaseNode( + ctx, + node, + name, + 'function', + objectKind, + name.qualified, + routineSignature(node, name, ctx.source) + ); + withCreatedScope(ctx, created, () => walkChildren(node, ctx)); + return true; +} + +function createType(node: SyntaxNode, ctx: ExtractorContext): boolean { + if (!hasDirectChild(node, 'kw_type')) return false; + const name = objectName(node, directChild(node, 'any_name'), ctx.source); + if (!name) return true; + const isEnum = hasDirectChild(node, 'kw_enum'); + const created = createDatabaseNode( + ctx, + node, + name, + isEnum ? 'enum' : 'type_alias', + isEnum ? 'enum' : 'type' + ); + withCreatedScope(ctx, created, () => { + if (isEnum) createEnumMembers(node, ctx); + walkChildren(node, ctx); + }); + return true; +} + +function createDomain(node: SyntaxNode, ctx: ExtractorContext): boolean { + const name = objectName(node, directChild(node, 'any_name'), ctx.source); + if (!name) return true; + const created = createDatabaseNode(ctx, node, name, 'type_alias', 'domain'); + withCreatedScope(ctx, created, () => walkChildren(node, ctx)); + return true; +} + +function createSchema(node: SyntaxNode, ctx: ExtractorContext): boolean { + const name = objectName(node, directChild(node, 'ColId', 'opt_single_name'), ctx.source); + if (!name) return true; + const created = createDatabaseNode(ctx, node, name, 'namespace', 'schema'); + withCreatedScope(ctx, created, () => walkChildren(node, ctx)); + return true; +} + +function createTrigger(node: SyntaxNode, ctx: ExtractorContext): boolean { + const triggerName = readSqlName(directChild(node, 'name'), ctx.source); + const tableNode = directChild(node, 'qualified_name'); + const tableName = readSqlName(tableNode, ctx.source); + if (!triggerName) return true; + + const qualifiedName = tableName + ? `${tableName.qualified}.${triggerName.simple}` + : triggerName.qualified; + const created = createDatabaseNode( + ctx, + node, + triggerName, + 'function', + node.type === 'CreateEventTrigStmt' ? 'event-trigger' : 'trigger', + qualifiedName + ); + withCreatedScope(ctx, created, () => { + if (created && tableNode && tableName) { + addReference(ctx, created.id, tableName, 'references', tableNode); + } + const routineNode = directChild(node, 'func_name'); + const routineName = readSqlName(routineNode, ctx.source); + if (created && routineNode && routineName) { + addReference(ctx, created.id, routineName, 'calls', routineNode); + } + walkChildren(node, ctx); + }); + return true; +} + +function createPolicy(node: SyntaxNode, ctx: ExtractorContext): boolean { + const policyName = readSqlName(directChild(node, 'name'), ctx.source); + const tableNode = directChild(node, 'qualified_name'); + const tableName = readSqlName(tableNode, ctx.source); + if (!policyName) return true; + const qualifiedName = tableName + ? `${tableName.qualified}.${policyName.simple}` + : policyName.qualified; + const created = createDatabaseNode( + ctx, + node, + policyName, + 'constant', + 'policy', + qualifiedName + ); + withCreatedScope(ctx, created, () => { + if (created && tableNode && tableName) { + addReference(ctx, created.id, tableName, 'references', tableNode); + } + walkChildren(node, ctx); + }); + return true; +} + +function createIndex(node: SyntaxNode, ctx: ExtractorContext): boolean { + const rawName = readSqlName(directChild(node, 'opt_single_name', 'name'), ctx.source); + const relation = directChild(node, 'relation_expr'); + const tableNode = relation ? firstDescendant(relation, 'qualified_name') : null; + const tableName = readSqlName(tableNode, ctx.source); + if (!rawName) { + walkChildren(node, ctx); + return true; + } + const schema = tableName && tableName.parts.length > 1 + ? tableName.parts.slice(0, -1).join('.') + : null; + const qualifiedName = schema ? `${schema}.${rawName.simple}` : rawName.qualified; + const created = createDatabaseNode( + ctx, + node, + rawName, + 'constant', + 'index', + qualifiedName + ); + withCreatedScope(ctx, created, () => walkChildren(node, ctx)); + return true; +} + +function createSequence(node: SyntaxNode, ctx: ExtractorContext): boolean { + const name = objectName(node, directChild(node, 'qualified_name'), ctx.source); + if (!name) return true; + const created = createDatabaseNode(ctx, node, name, 'variable', 'sequence'); + withCreatedScope(ctx, created, () => walkChildren(node, ctx)); + return true; +} + +function createExtension(node: SyntaxNode, ctx: ExtractorContext): boolean { + const name = readSqlName(directChild(node, 'name'), ctx.source); + if (!name) return true; + const created = createDatabaseNode(ctx, node, name, 'constant', 'extension'); + withCreatedScope(ctx, created, () => walkChildren(node, ctx)); + return true; +} + +const QUERY_SCOPE_TYPES = new Set([ + 'select_no_parens', + 'InsertStmt', + 'UpdateStmt', + 'DeleteStmt', +]); + +const QUERY_BOUNDARY_TYPES = new Set([ + ...QUERY_SCOPE_TYPES, + 'SelectStmt', + 'select_with_parens', +]); + +/** + * Find the WITH clause owned by one query level. The grammar wraps it in nodes + * such as `select_no_parens`, so it is not necessarily a direct child. Nested + * query statements are hard boundaries: their WITH clauses are not visible to + * an outer relation that happens to share the same alias. + */ +function ownWithClause(query: SyntaxNode): SyntaxNode | null { + const visit = (node: SyntaxNode): SyntaxNode | null => { + for (const child of children(node)) { + if (child.type === 'with_clause') return child; + if (QUERY_BOUNDARY_TYPES.has(child.type)) continue; + const found = visit(child); + if (found) return found; + } + return null; + }; + return visit(query); +} + +function cteNamesInClause(withClause: SyntaxNode, source: string): Set { + const names = new Set(); + const visit = (node: SyntaxNode): void => { + for (const child of children(node)) { + if (child.type === 'common_table_expr') { + const name = readSqlName(directChild(child, 'name'), source); + if (name) names.add(name.qualified); + // Do not enter the CTE body: a nested query may own another WITH clause. + continue; + } + visit(child); + } + }; + visit(withClause); + return names; +} + +function cteNamesVisibleFrom(node: SyntaxNode, source: string): Set { + const names = new Set(); + let ancestor: SyntaxNode | null = node; + while (ancestor) { + if (QUERY_SCOPE_TYPES.has(ancestor.type)) { + const withClause = ownWithClause(ancestor); + if (withClause) { + for (const name of cteNamesInClause(withClause, source)) names.add(name); + } + } + ancestor = ancestor.parent; + } + return names; +} + +function emitRelationReference(node: SyntaxNode, ctx: ExtractorContext): boolean { + const nameNode = firstDescendant(node, 'qualified_name'); + const name = readSqlName(nameNode, ctx.source); + const fromNodeId = currentScopeId(ctx); + if (!nameNode || !name || !fromNodeId) return true; + if (name.parts.length === 1 && cteNamesVisibleFrom(node, ctx.source).has(name.qualified)) { + return true; + } + addReference(ctx, fromNodeId, name, 'references', nameNode); + walkChildren(node, ctx); + return true; +} + +function emitForeignKeyReference(node: SyntaxNode, ctx: ExtractorContext): boolean { + const fromNodeId = currentScopeId(ctx); + const marker = directChild(node, 'kw_references'); + if (fromNodeId && marker) { + const targetNode = children(node).find( + (child) => child.type === 'qualified_name' && child.startIndex > marker.endIndex + ) ?? null; + const target = readSqlName(targetNode, ctx.source); + if (targetNode && target) addReference(ctx, fromNodeId, target, 'references', targetNode); + } + walkChildren(node, ctx); + return true; +} + +function emitRoutineCall(node: SyntaxNode, ctx: ExtractorContext): boolean { + const nameNode = directChild(node, 'func_name'); + const name = readSqlName(nameNode, ctx.source); + const fromNodeId = currentScopeId(ctx); + if ( + nameNode && + name && + fromNodeId && + !(name.parts.length === 1 && BUILTIN_ROUTINES.has(name.simple)) + ) { + addReference(ctx, fromNodeId, name, 'calls', nameNode); + } + walkChildren(node, ctx); + return true; +} + +export const postgresExtractor: LanguageExtractor = { + // All relevant grammar nodes have empty field maps, so visitNode owns the + // PostgreSQL dispatch. Empty generic mappings prevent accidental extraction + // from wrapper names such as `name` / `ColId`. + functionTypes: [], + classTypes: [], + methodTypes: [], + interfaceTypes: [], + structTypes: [], + enumTypes: [], + enumMemberTypes: [], + typeAliasTypes: [], + importTypes: [], + callTypes: [], + variableTypes: [], + fieldTypes: [], + nameField: '', + bodyField: '', + paramsField: '', + + visitNode: (node, ctx) => { + switch (node.type) { + case 'CreateStmt': + case 'CreateForeignTableStmt': + return createTableLike( + node, + ctx, + directChild(node, 'qualified_name'), + node.type === 'CreateForeignTableStmt' ? 'foreign-table' : 'table' + ); + + case 'CreateAsStmt': { + const target = directChild(node, 'create_as_target'); + return createTableLike( + node, + ctx, + target ? firstDescendant(target, 'qualified_name') : null, + 'table', + target + ); + } + + case 'ViewStmt': + return createTableLike(node, ctx, directChild(node, 'qualified_name'), 'view', node); + + case 'CreateMatViewStmt': { + const target = directChild(node, 'create_mv_target'); + return createTableLike( + node, + ctx, + target ? firstDescendant(target, 'qualified_name') : null, + 'materialized-view', + target + ); + } + + case 'CreateFunctionStmt': + return createRoutine(node, ctx); + + case 'CreateSchemaStmt': + return createSchema(node, ctx); + + case 'DefineStmt': + return createType(node, ctx); + + case 'CreateDomainStmt': + return createDomain(node, ctx); + + case 'CreateTrigStmt': + case 'CreateEventTrigStmt': + return createTrigger(node, ctx); + + case 'CreatePolicyStmt': + return createPolicy(node, ctx); + + case 'IndexStmt': + return createIndex(node, ctx); + + case 'CreateSeqStmt': + return createSequence(node, ctx); + + case 'CreateExtensionStmt': + return createExtension(node, ctx); + + case 'columnDef': { + const nameNode = directChild(node, 'ColId'); + const scope = currentScopeNode(ctx); + const isTableColumn = scope?.decorators?.some( + (decorator) => decorator === 'postgres:table' || decorator === 'postgres:foreign-table' + ) ?? false; + if (nameNode && isTableColumn) createColumn(ctx, node, nameNode); + walkChildren(node, ctx); + return true; + } + + case 'ConstraintElem': + case 'ColConstraintElem': + return emitForeignKeyReference(node, ctx); + + case 'relation_expr': + case 'insert_target': + return emitRelationReference(node, ctx); + + case 'func_application': + return emitRoutineCall(node, ctx); + + default: + return false; + } + }, +}; diff --git a/src/extraction/wasm/tree-sitter-postgres.LICENSE b/src/extraction/wasm/tree-sitter-postgres.LICENSE new file mode 100644 index 000000000..bb61fcdac --- /dev/null +++ b/src/extraction/wasm/tree-sitter-postgres.LICENSE @@ -0,0 +1,25 @@ +Copyright (c) 2026 Gavin M. Roy, AWeber +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + * Neither the name of the copyright holder nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, +INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE +OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/src/extraction/wasm/tree-sitter-postgres.wasm b/src/extraction/wasm/tree-sitter-postgres.wasm new file mode 100644 index 0000000000000000000000000000000000000000..98c2be25b37131dbf8b9a5f52f0837d34f598c17 GIT binary patch literal 14853663 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

Is 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

  • rXmMy_w684|$ojGINyh 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

    %j+#jCBi4i^ZE_XdldwNm7TimYdZ(WyXcJa9| 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 { + if (node.language !== 'postgres') return false; + if (isCallable) { + return node.kind === 'function' && ( + node.decorators?.includes('postgres:function') === true || + node.decorators?.includes('postgres:procedure') === true + ); + } + return node.kind === 'struct'; + }; + + const isQualified = ref.referenceName.includes('::') || ref.referenceName.includes('.'); + const candidates = (isQualified + ? context.getNodesByQualifiedName(ref.referenceName) + : context.getNodesByName(ref.referenceName) + ).filter(eligible); + if (candidates.length === 0) return null; + + const sameFile = candidates.filter((node) => node.filePath === ref.filePath); + let target: Node | undefined; + if (sameFile.length === 1) { + target = sameFile[0]; + } else if (sameFile.length > 1) { + return null; + } else if (candidates.length === 1) { + target = candidates[0]; + } else { + return null; + } + if (!target) return null; + + return { + original: ref, + targetNodeId: target.id, + confidence: isQualified ? 0.95 : 0.9, + resolvedBy: + ref.referenceKind === 'function_ref' + ? 'function-ref' + : isQualified + ? 'qualified-name' + : 'exact-match', + }; +} + /** * A function nested inside another FUNCTION is only callable from within its * container — Python, JS/TS, and every closure language scope it lexically. @@ -2218,6 +2290,13 @@ export function matchReference( ref: UnresolvedRef, context: ResolutionContext ): ResolvedRef | null { + // PostgreSQL migration trees routinely contain duplicate object names across + // schemas and historical revisions. They must never reach the generic + // qualified-name suffix, fuzzy, or path-proximity fallbacks. + if (ref.language === 'postgres') { + return matchPostgresReference(ref, context); + } + // Function-as-value refs (#756) resolve ONLY through the dedicated matcher — // never the fuzzy/qualified fallthrough below (a wrong callback edge is // worse than none). diff --git a/src/types.ts b/src/types.ts index 5b0e407c5..d2d026087 100644 --- a/src/types.ts +++ b/src/types.ts @@ -116,6 +116,7 @@ export const LANGUAGES = [ 'vbnet', 'erlang', 'terraform', + 'postgres', 'unknown', ] as const; From 1dded0745b2cc82b41d0855107a5584e3cad8a30 Mon Sep 17 00:00:00 2001 From: Daniel Hritcu <134442484+dhritcu@users.noreply.github.com> Date: Fri, 31 Jul 2026 13:33:28 -0400 Subject: [PATCH 2/4] fix(postgres): preserve routine calls and alter-column deltas --- CHANGELOG.md | 2 +- README.md | 2 +- __tests__/postgres-extraction.test.ts | 88 +++++++++++++++-- src/extraction/languages/postgres.ts | 137 +++++++++++++------------- 4 files changed, 152 insertions(+), 77 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index c65e65b53..284181b5d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -11,7 +11,7 @@ and adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). ### New Features -- PostgreSQL projects can now index `.sql`, `.psql`, and `.pgsql` files, including schemas, tables and their `CREATE TABLE` columns, views, routines, types, triggers, policies, indexes, sequences, extensions, and their common table, foreign-key, trigger, and routine dependencies; columns added later by `ALTER TABLE`, and string-literal routine bodies including dollar-quoted PL/pgSQL, remain opaque for now. +- PostgreSQL projects can now index `.sql`, `.psql`, and `.pgsql` files, including schemas, tables and columns introduced by `CREATE TABLE` or `ALTER TABLE ... ADD COLUMN`, views, routines, types, triggers, policies, indexes, sequences, extensions, and their common table, foreign-key, trigger, and routine dependencies. Altered columns are retained as relation-linked migration deltas instead of being attached to an arbitrary historical table definition; string-literal routine bodies, including dollar-quoted PL/pgSQL, remain opaque for now. ## [1.5.0] - 2026-07-21 diff --git a/README.md b/README.md index 1d0549330..b894144dd 100644 --- a/README.md +++ b/README.md @@ -794,7 +794,7 @@ is written): | Erlang | `.erl`, `.hrl`, `.escript`, `.app.src`, `.app` | Full support (functions with multi-clause/multi-arity grouping, `-spec` signatures, records with fields, `-type`/`-opaque` aliases, `-define` macros, `-include`/`-include_lib`/`-import` edges, local and `mod:fn` remote call edges, `fun name/arity` references, `spawn`/`apply`/`proc_lib`/`timer`/`rpc` MFA-argument call edges, `gen_server:call/cast(?MODULE)` → own `handle_call`/`handle_cast` links, `-behaviour` links, `-export`-based visibility) | | Solidity | `.sol` | Full support (contracts, libraries, interfaces, structs, enums, modifiers, events, errors, state variables, `import`/`using` directives, `emit`/`revert` calls) | | Terraform / OpenTofu | `.tf`, `.tfvars`, `.tofu` | Full support (resources, data sources, modules, variables, outputs, providers incl. aliases, `locals`; `var.`/`local.`/`module.`/resource references with Terraform's per-directory scoping enforced; module calls bridged across the boundary — inputs to the child module's variables, `module.M.out` to the child's output, `source` to the module's files; cloudposse/atmos `remote-state` cross-component wiring when the component is statically named; `provider = aws.east` selections resolved up the module tree; `moved`/`import`/`removed`/`check` block references; `.tfvars` assignments linked to the variables they set) | -| PostgreSQL | `.sql`, `.psql`, `.pgsql` | Initial support (schemas, tables and their `CREATE TABLE` columns, views/materialized views, functions/procedures, enums/domains, triggers, policies, indexes, sequences, extensions, foreign keys, relation dependencies, and routine calls; columns added later by `ALTER TABLE`, and string-literal routine bodies including dollar-quoted PL/pgSQL, are not parsed yet) | +| PostgreSQL | `.sql`, `.psql`, `.pgsql` | Initial support (schemas, tables and columns introduced by `CREATE TABLE` or relation-linked `ALTER TABLE ... ADD COLUMN` migration deltas, views/materialized views, functions/procedures, enums/domains, triggers, policies, indexes, sequences, extensions, foreign keys, relation dependencies, and routine calls; string-literal routine bodies including dollar-quoted PL/pgSQL are not parsed yet) | | Nix | `.nix` | Full support (functions with simple/destructured/curried params, `let`/attrset bindings, `inherit`, `import ./path` file edges — `./dir` resolving through `default.nix` — plus NixOS module `imports = [ ./x.nix ]` lists and `callPackage ./pkg.nix` file edges; call edges; module-system option wiring — a config write like `launchd.user.agents.x = { ... }` links to the module declaring `options.launchd.user.agents`, so option flows trace across modules) | ## Measured cross-file coverage diff --git a/__tests__/postgres-extraction.test.ts b/__tests__/postgres-extraction.test.ts index c7f00c9c2..8eca2ac9b 100644 --- a/__tests__/postgres-extraction.test.ts +++ b/__tests__/postgres-extraction.test.ts @@ -88,6 +88,23 @@ describe('PostgreSQL extraction', () => { expect(refs.some((ref) => ref.referenceName === 'recent')).toBe(false); }); + it('retains calls whose names collide with PostgreSQL built-ins', () => { + const result = extract([ + 'CREATE VIEW app.dashboard AS', + 'SELECT count(*), lower(app.display_name), app.custom_metric()', + 'FROM app.users;', + ].join('\n')); + + const view = result.nodes.find((node) => node.qualifiedName === 'app.dashboard'); + expect(view).toBeTruthy(); + + const calls = result.unresolvedReferences + .filter((ref) => ref.fromNodeId === view!.id && ref.referenceKind === 'calls') + .map((ref) => ref.referenceName) + .sort(); + expect(calls).toEqual(['app.custom_metric', 'count', 'lower']); + }); + it('does not leak a nested query CTE alias into the outer query scope', () => { const result = extract([ 'SELECT * FROM recent', @@ -126,17 +143,40 @@ describe('PostgreSQL extraction', () => { expect(fileRefs).toEqual(['App.Users', 'public.teams']); }); - it('does not create file-scoped fields for ALTER TABLE ADD COLUMN', () => { + it('models ALTER TABLE ADD COLUMN as a relation-linked migration delta', () => { const result = extract([ 'CREATE TABLE app.users (id bigint);', - 'ALTER TABLE app.users ADD COLUMN email text;', + 'ALTER TABLE app.users', + ' ADD COLUMN email text,', + ' ADD COLUMN IF NOT EXISTS display_name text;', ].join('\n')); - const fields = result.nodes.filter((node) => node.kind === 'field'); - expect(fields.map((node) => node.qualifiedName)).toEqual(['app.users.id']); - expect(result.unresolvedReferences.some( - (ref) => ref.referenceKind === 'references' && ref.referenceName === 'app.users' - )).toBe(true); + const fields = result.nodes + .filter((node) => node.kind === 'field') + .map((node) => node.qualifiedName) + .sort(); + expect(fields).toEqual(['app.users.display_name', 'app.users.email', 'app.users.id']); + + const deltas = result.nodes.filter( + (node) => node.decorators?.includes('postgres:alter-table-add-column') + ); + expect(deltas.map((node) => node.qualifiedName).sort()).toEqual([ + 'app.users.ADD COLUMN display_name', + 'app.users.ADD COLUMN email', + ]); + + for (const delta of deltas) { + expect(result.unresolvedReferences.some( + (ref) => ref.fromNodeId === delta.id && + ref.referenceKind === 'references' && + ref.referenceName === 'app.users' + )).toBe(true); + expect(result.edges.some( + (edge) => edge.source === delta.id && + edge.kind === 'contains' && + result.nodes.find((candidate) => candidate.id === edge.target)?.kind === 'field' + )).toBe(true); + } }); it('keeps dollar-quoted PL/pgSQL bodies opaque in the PostgreSQL-only phase', () => { @@ -188,4 +228,38 @@ describe('PostgreSQL extraction', () => { fs.rmSync(projectDir, { recursive: true, force: true }); } }); + + it('resolves an unqualified user routine that shadows a PostgreSQL built-in name', async () => { + const projectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-postgres-shadow-')); + fs.writeFileSync( + path.join(projectDir, '001_count.sql'), + "CREATE FUNCTION count(value integer) RETURNS integer LANGUAGE sql AS 'SELECT value';\n" + ); + fs.writeFileSync( + path.join(projectDir, '002_summary.sql'), + 'CREATE VIEW app.summary AS SELECT count(1);\n' + ); + + const graph = CodeGraph.initSync(projectDir); + try { + await graph.indexAll(); + + const routine = graph.getNodesByName('count').find( + (node) => node.language === 'postgres' && node.decorators?.includes('postgres:function') + ); + const view = graph.getNodesByName('summary').find( + (node) => node.qualifiedName === 'app.summary' + ); + expect(routine).toBeTruthy(); + expect(view).toBeTruthy(); + + const incoming = graph.getIncomingEdges(routine!.id); + expect(incoming.some( + (edge) => edge.source === view!.id && edge.kind === 'calls' + )).toBe(true); + } finally { + graph.destroy(); + fs.rmSync(projectDir, { recursive: true, force: true }); + } + }); }); diff --git a/src/extraction/languages/postgres.ts b/src/extraction/languages/postgres.ts index d32bb46d8..e97c98e8e 100644 --- a/src/extraction/languages/postgres.ts +++ b/src/extraction/languages/postgres.ts @@ -28,66 +28,6 @@ type ReferenceKind = 'references' | 'calls'; const NAME_SEGMENT_TYPES = new Set(['ColId', 'ColLabel', 'type_function_name']); -// Avoid filling unresolved_refs with ubiquitous PostgreSQL/SQL built-ins. A -// schema-qualified spelling is never filtered because it may be user-defined. -const BUILTIN_ROUTINES = new Set([ - 'any', - 'array_length', - 'array_remove', - 'array_agg', - 'avg', - 'bool_or', - 'cast', - 'coalesce', - 'concat', - 'count', - 'current_date', - 'current_setting', - 'current_time', - 'current_timestamp', - 'date_part', - 'date_trunc', - 'encode', - 'extract', - 'first_value', - 'gen_random_uuid', - 'greatest', - 'json_agg', - 'json_build_array', - 'json_build_object', - 'jsonb_agg', - 'jsonb_array_elements_text', - 'jsonb_array_length', - 'jsonb_build_array', - 'jsonb_build_object', - 'jsonb_set', - 'jsonb_strip_nulls', - 'jsonb_typeof', - 'least', - 'length', - 'lower', - 'max', - 'min', - 'nextval', - 'now', - 'nullif', - 'position', - 'round', - 'row_number', - 'row_to_json', - 'set_config', - 'split_part', - 'substring', - 'sum', - 'to_char', - 'to_date', - 'to_json', - 'to_jsonb', - 'trim', - 'unnest', - 'upper', -]); - /** Per-extraction reference de-duplication. `ctx.nodes` is stable for a file. */ const emittedReferenceKeys = new WeakMap>(); @@ -262,10 +202,15 @@ function walkChildren(node: SyntaxNode, ctx: ExtractorContext): void { for (const child of children(node)) ctx.visitNode(child); } -function createColumn(ctx: ExtractorContext, node: SyntaxNode, nameNode: SyntaxNode): void { +function createColumn( + ctx: ExtractorContext, + node: SyntaxNode, + nameNode: SyntaxNode, + parentQualifiedOverride?: string +): void { const name = readSqlName(nameNode, ctx.source); if (!name) return; - const parentQualified = currentScopeQualifiedName(ctx); + const parentQualified = parentQualifiedOverride ?? currentScopeQualifiedName(ctx); ctx.createNode('field', name.simple, node, { qualifiedName: parentQualified ? `${parentQualified}.${name.simple}` : name.qualified, signature: compactText(node, ctx.source, 200), @@ -493,6 +438,60 @@ function createExtension(node: SyntaxNode, ctx: ExtractorContext): boolean { return true; } +/** + * Model ALTER TABLE ADD COLUMN as a migration delta rather than attaching the + * new field to an arbitrary historical CREATE TABLE node. The delta references + * its target relation and contains a normally searchable table-qualified field; + * a future ordered-migration layer can fold these deltas into an effective + * schema without changing the extracted facts. + */ +function createAlterTableDeltas(node: SyntaxNode, ctx: ExtractorContext): boolean { + const relation = directChild(node, 'relation_expr'); + const tableNode = relation ? firstDescendant(relation, 'qualified_name') : null; + const tableName = readSqlName(tableNode, ctx.source); + const ownerId = currentScopeId(ctx); + if (!tableNode || !tableName || !ownerId) { + walkChildren(node, ctx); + return true; + } + + // Retain the statement-level dependency that ALTER TABLE emitted before + // column deltas were modeled. + addReference(ctx, ownerId, tableName, 'references', tableNode); + + const commands = directChild(node, 'alter_table_cmds'); + if (!commands) return true; + for (const command of allDescendants(commands, 'alter_table_cmd')) { + const column = directChild(command, 'columnDef'); + const columnNameNode = column ? directChild(column, 'ColId') : null; + const columnName = readSqlName(columnNameNode, ctx.source); + if (!hasDirectChild(command, 'kw_add') || !column || !columnNameNode || !columnName) { + ctx.visitNode(command); + continue; + } + + const deltaSimple = `ADD COLUMN ${columnName.simple}`; + const deltaName: SqlName = { + parts: [...tableName.parts, deltaSimple], + qualified: `${tableName.qualified}.${deltaSimple}`, + simple: deltaSimple, + }; + const created = createDatabaseNode( + ctx, + command, + deltaName, + 'constant', + 'alter-table-add-column' + ); + withCreatedScope(ctx, created, () => { + if (created) addReference(ctx, created.id, tableName, 'references', tableNode); + createColumn(ctx, column, columnNameNode, tableName.qualified); + walkChildren(command, ctx); + }); + } + return true; +} + const QUERY_SCOPE_TYPES = new Set([ 'select_no_parens', 'InsertStmt', @@ -588,12 +587,11 @@ function emitRoutineCall(node: SyntaxNode, ctx: ExtractorContext): boolean { const nameNode = directChild(node, 'func_name'); const name = readSqlName(nameNode, ctx.source); const fromNodeId = currentScopeId(ctx); - if ( - nameNode && - name && - fromNodeId && - !(name.parts.length === 1 && BUILTIN_ROUTINES.has(name.simple)) - ) { + // Emit every routine-shaped call. PostgreSQL permits user routines to share + // names with pg_catalog routines (overload resolution and search_path decide + // the target), so filtering an unqualified name here would erase valid + // project edges before the resolver can inspect the indexed declarations. + if (nameNode && name && fromNodeId) { addReference(ctx, fromNodeId, name, 'calls', nameNode); } walkChildren(node, ctx); @@ -684,6 +682,9 @@ export const postgresExtractor: LanguageExtractor = { case 'CreateExtensionStmt': return createExtension(node, ctx); + case 'AlterTableStmt': + return createAlterTableDeltas(node, ctx); + case 'columnDef': { const nameNode = directChild(node, 'ColId'); const scope = currentScopeNode(ctx); From e953bd1624fbbd7c83e00e4c2e9e0efdd5ef9523 Mon Sep 17 00:00:00 2001 From: Daniel Hritcu <134442484+dhritcu@users.noreply.github.com> Date: Fri, 31 Jul 2026 21:21:43 -0400 Subject: [PATCH 3/4] feat(postgres): model relational dependencies --- __tests__/db-perf.test.ts | 69 +- __tests__/foundation.test.ts | 2 +- __tests__/postgres-extraction.test.ts | 630 +++++++++++++++- __tests__/postgres-name-matcher.test.ts | 675 +++++++++++++++++- __tests__/pr19-improvements.test.ts | 2 +- __tests__/security.test.ts | 9 +- __tests__/symbol-lookup.test.ts | 174 +++++ src/bin/codegraph.ts | 16 +- src/db/index.ts | 40 +- src/db/migrations.ts | 14 +- src/db/queries.ts | 228 +++++- src/db/schema.sql | 8 + src/extraction/extraction-version.ts | 2 +- src/extraction/languages/postgres.ts | 617 ++++++++++++++-- src/index.ts | 23 +- src/mcp/tools.ts | 195 ++++- src/postgres/foreign-key.ts | 49 ++ src/postgres/identifiers.ts | 79 ++ src/postgres/search-path.ts | 485 +++++++++++++ src/postgres/table-relation.ts | 49 ++ src/postgres/temporary-relations.ts | 375 ++++++++++ src/resolution/callback-synthesizer.ts | 2 +- src/resolution/index.ts | 35 + src/resolution/name-matcher.ts | 156 +++- .../postgres-foreign-key-synthesizer.ts | 250 +++++++ .../postgres-structure-synthesizer.ts | 262 +++++++ 26 files changed, 4320 insertions(+), 126 deletions(-) create mode 100644 src/postgres/foreign-key.ts create mode 100644 src/postgres/identifiers.ts create mode 100644 src/postgres/search-path.ts create mode 100644 src/postgres/table-relation.ts create mode 100644 src/postgres/temporary-relations.ts create mode 100644 src/resolution/postgres-foreign-key-synthesizer.ts create mode 100644 src/resolution/postgres-structure-synthesizer.ts diff --git a/__tests__/db-perf.test.ts b/__tests__/db-perf.test.ts index 9be0803b2..574b512d7 100644 --- a/__tests__/db-perf.test.ts +++ b/__tests__/db-perf.test.ts @@ -252,6 +252,73 @@ describe('runMaintenance', () => { }); }); +describe('bulk-load index crash recovery', () => { + it('recreates every secondary index dropped by interrupted bulk-load windows on reopen', () => { + const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'db-bulk-heal-')); + const dbPath = path.join(dir, 'test.db'); + const db = DatabaseConnection.initialize(dbPath); + + // Simulate a process dying with all three bulk windows open. close() does + // not repair schema objects, so the persisted database matches the state a + // SIGKILL would leave behind. + db.beginBulkParseLoad(); + db.beginBulkRefLoad(); + + const dropped = [ + 'idx_nodes_kind', + 'idx_nodes_name', + 'idx_nodes_qualified_name', + 'idx_nodes_file_path', + 'idx_nodes_language', + 'idx_nodes_file_line', + 'idx_nodes_lower_name', + 'idx_unresolved_from_node', + 'idx_unresolved_name', + 'idx_unresolved_file_path', + 'idx_unresolved_from_name', + 'idx_unresolved_status', + 'idx_unresolved_failed_tail', + 'idx_files_language', + 'idx_files_modified_at', + 'idx_edges_kind', + 'idx_edges_source_kind', + 'idx_edges_target_kind', + 'idx_edges_provenance', + 'idx_edges_synthesized_by', + ]; + const indexExists = (connection: DatabaseConnection, name: string) => + connection + .getDb() + .prepare("SELECT 1 FROM sqlite_master WHERE type = 'index' AND name = ?") + .get(name); + + for (const name of dropped) expect(indexExists(db, name)).toBeUndefined(); + db.close(); + + const reopened = DatabaseConnection.open(dbPath); + try { + for (const name of dropped) expect(indexExists(reopened, name), name).toBeTruthy(); + + // The new expression index is not merely present by name: SQLite can use + // it for the ownership predicate exercised by whole-graph synthesizers. + const plan = reopened + .getDb() + .prepare( + `EXPLAIN QUERY PLAN + SELECT source, target, kind + FROM edges + WHERE json_extract(CASE WHEN json_valid(metadata) THEN metadata ELSE '{}' END, '$.synthesizedBy') = ? + AND json_extract(CASE WHEN json_valid(metadata) THEN metadata ELSE '{}' END, '$.synthesizedBy') IS NOT NULL` + ) + .all('postgres-foreign-key') as Array<{ detail: string }>; + expect(plan.map((row) => row.detail).join(' ')).toContain('idx_edges_synthesized_by'); + } finally { + reopened.close(); + fs.rmSync(dir, { recursive: true, force: true }); + } + }); +}); + // The edges table carried no UNIQUE constraint, so `insertEdge`'s // `INSERT OR IGNORE` had nothing to conflict on and silently admitted // byte-identical duplicate rows when two passes emitted the same edge (#1034). @@ -344,7 +411,7 @@ describe('migration v6: dedup edges + add identity index on upgrade (#1034)', () runMigrations(raw, 5); expect(count()).toBe(2); // duplicate collapsed, the distinct `calls` edge kept - expect(getCurrentVersion(raw)).toBe(8); + expect(getCurrentVersion(raw)).toBe(9); const idx = raw .prepare("SELECT name FROM sqlite_master WHERE type='index' AND name='idx_edges_identity'") .get(); diff --git a/__tests__/foundation.test.ts b/__tests__/foundation.test.ts index 8ed73123e..08b9f222f 100644 --- a/__tests__/foundation.test.ts +++ b/__tests__/foundation.test.ts @@ -370,7 +370,7 @@ describe('Database Connection', () => { const version = db.getSchemaVersion(); expect(version).not.toBeNull(); - expect(version?.version).toBe(8); + expect(version?.version).toBe(9); db.close(); }); diff --git a/__tests__/postgres-extraction.test.ts b/__tests__/postgres-extraction.test.ts index 8eca2ac9b..a2d680748 100644 --- a/__tests__/postgres-extraction.test.ts +++ b/__tests__/postgres-extraction.test.ts @@ -5,6 +5,14 @@ import * as path from 'node:path'; import { CodeGraph } from '../src'; import { extractFromSource } from '../src/extraction'; import { initGrammars, loadGrammarsForLanguages } from '../src/extraction/grammars'; +import { + POSTGRES_FOREIGN_KEY_DECORATOR, + decodePostgresForeignKeyDescriptor, +} from '../src/postgres/foreign-key'; +import { + POSTGRES_TABLE_RELATION_DECORATOR, + decodePostgresTableRelationDescriptor, +} from '../src/postgres/table-relation'; beforeAll(async () => { await initGrammars(); @@ -61,6 +69,20 @@ describe('PostgreSQL extraction', () => { expect(byQualifiedName.get('app.users_email_idx')?.decorators).toContain('postgres:index'); expect(byQualifiedName.get('app.event_id_seq')?.decorators).toContain('postgres:sequence'); expect(byQualifiedName.get('pgcrypto')?.decorators).toContain('postgres:extension'); + + const trigger = byQualifiedName.get('app.users.users_touch')!; + expect(result.unresolvedReferences).toEqual(expect.arrayContaining([ + expect.objectContaining({ + fromNodeId: trigger.id, + referenceKind: 'references', + referenceName: 'app.users', + }), + expect.objectContaining({ + fromNodeId: trigger.id, + referenceKind: 'calls', + referenceName: 'app.touch_user', + }), + ])); }); it('emits and de-duplicates relation and routine references while ignoring CTE aliases', () => { @@ -131,8 +153,8 @@ describe('PostgreSQL extraction', () => { 'SELECT * FROM "App"."Users";', ].join('\n')); - expect(result.nodes.some((node) => node.qualifiedName === 'App.Users')).toBe(true); - expect(result.nodes.some((node) => node.qualifiedName === 'App.Users.ID')).toBe(true); + expect(result.nodes.some((node) => node.qualifiedName === '"App"."Users"')).toBe(true); + expect(result.nodes.some((node) => node.qualifiedName === '"App"."Users"."ID"')).toBe(true); expect(result.nodes.some((node) => node.qualifiedName === 'public.teams')).toBe(true); const file = result.nodes.find((node) => node.kind === 'file')!; @@ -140,7 +162,260 @@ describe('PostgreSQL extraction', () => { .filter((ref) => ref.fromNodeId === file.id && ref.referenceKind === 'references') .map((ref) => ref.referenceName) .sort(); - expect(fileRefs).toEqual(['App.Users', 'public.teams']); + expect(fileRefs).toEqual(['"App"."Users"']); + + const foreignKey = result.nodes.find((node) => + node.decorators?.includes(POSTGRES_FOREIGN_KEY_DECORATOR) + ); + expect(foreignKey).toBeTruthy(); + expect(foreignKey!.qualifiedName).toBe('"App"."Users".users_team_fk'); + expect(decodePostgresForeignKeyDescriptor(foreignKey!.decorators)).toEqual({ + sourceTable: '"App"."Users"', + targetTable: 'public.teams', + constraintName: 'users_team_fk', + sourceColumns: ['ID'], + targetColumns: ['id'], + }); + expect(result.unresolvedReferences + .filter((ref) => ref.fromNodeId === foreignKey!.id) + .map((ref) => ref.referenceName) + .sort() + ).toEqual(['"App"."Users"', 'public.teams']); + }); + + it('preserves quoted identifier segment boundaries and escaped quotes', () => { + const result = extract( + 'CREATE TABLE "public.app".users (id bigint); ' + + 'CREATE TABLE public."app.users" (id bigint); ' + + 'CREATE TABLE "a""b"."c.d" ("e.f" bigint);' + ); + const tables = result.nodes + .filter((node) => node.kind === 'struct') + .map((node) => node.qualifiedName); + expect(tables).toEqual(expect.arrayContaining([ + '"public.app".users', + 'public."app.users"', + '"a""b"."c.d"', + ])); + expect(new Set(result.nodes.map((node) => node.id)).size).toBe(result.nodes.length); + expect(result.nodes.some((node) => node.qualifiedName === '"public.app".users.id')).toBe(true); + expect(result.nodes.some((node) => node.qualifiedName === 'public."app.users".id')).toBe(true); + expect(result.nodes.some((node) => node.qualifiedName === '"a""b"."c.d"."e.f"')).toBe(true); + }); + + it('indexes authorization-only schemas, dynamic nested DDL, and temporary tables safely', () => { + const result = extract([ + 'CREATE SCHEMA AUTHORIZATION joe CREATE TABLE users (id bigint);', + 'CREATE SCHEMA AUTHORIZATION CURRENT_USER CREATE TABLE runtime_table (id bigint);', + 'CREATE TABLE public.sessions (id bigint);', + 'CREATE TEMP TABLE sessions (id bigint);', + 'ALTER TABLE sessions ADD COLUMN token text;', + 'CREATE TEMP TABLE session_copy AS SELECT * FROM sessions;', + 'CREATE TEMP VIEW active_sessions AS SELECT * FROM sessions;', + 'CREATE TEMPORARY SEQUENCE session_ids;', + 'CREATE VIEW pg_temp.explicit_temp_view AS SELECT 1;', + 'CREATE SEQUENCE pg_temp.explicit_temp_sequence;', + 'DROP TABLE sessions;', + 'ALTER TABLE sessions ADD COLUMN persistent_token text;', + 'CREATE UNLOGGED TABLE events (id bigint);', + ].join('\n')); + const byQualifiedName = new Map(result.nodes.map((node) => [node.qualifiedName, node])); + expect(byQualifiedName.get('joe')?.decorators).toContain('postgres:schema'); + expect(byQualifiedName.get('joe.users')?.decorators).toContain('postgres:table'); + expect(byQualifiedName.get('joe.users.id')?.decorators).toContain('postgres:column'); + expect(byQualifiedName.get('runtime_table')?.decorators).toContain('postgres:table'); + expect(byQualifiedName.has('public.runtime_table')).toBe(false); + expect(byQualifiedName.get('public.sessions')?.decorators).not.toContain('postgres:temporary'); + expect(byQualifiedName.get('pg_temp.sessions')?.decorators).toEqual(expect.arrayContaining([ + 'postgres:table', + 'postgres:temporary', + ])); + expect(byQualifiedName.get('pg_temp.sessions.id')?.decorators).toContain('postgres:column'); + expect(byQualifiedName.get('pg_temp.sessions."ADD COLUMN token"')).toBeTruthy(); + expect(byQualifiedName.get('pg_temp.session_copy')?.decorators).toContain('postgres:temporary'); + expect(byQualifiedName.get('pg_temp.active_sessions')?.decorators).toEqual( + expect.arrayContaining(['postgres:view', 'postgres:temporary']) + ); + expect(byQualifiedName.get('pg_temp.session_ids')?.decorators).toEqual( + expect.arrayContaining(['postgres:sequence', 'postgres:temporary']) + ); + expect(byQualifiedName.get('pg_temp.explicit_temp_view')?.decorators).toEqual( + expect.arrayContaining(['postgres:view', 'postgres:temporary']) + ); + expect(byQualifiedName.get('pg_temp.explicit_temp_sequence')?.decorators).toEqual( + expect.arrayContaining(['postgres:sequence', 'postgres:temporary']) + ); + expect(byQualifiedName.get('public.sessions."ADD COLUMN persistent_token"')).toBeTruthy(); + expect(byQualifiedName.get('public.events')?.decorators).not.toContain('postgres:temporary'); + }); + + it('links both tables and the routine named by a constraint trigger', () => { + const result = extract([ + 'CREATE TABLE app.orders (id bigint);', + 'CREATE TABLE app.users (id bigint);', + 'CREATE FUNCTION app.check_order() RETURNS trigger LANGUAGE plpgsql AS $$ BEGIN RETURN NEW; END $$;', + 'CREATE CONSTRAINT TRIGGER orders_check AFTER INSERT ON app.orders FROM app.users', + ' DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION app.check_order();', + ].join('\n')); + const trigger = result.nodes.find((node) => node.name === 'orders_check')!; + expect(result.unresolvedReferences + .filter((ref) => ref.fromNodeId === trigger.id) + .map((ref) => `${ref.referenceKind}:${ref.referenceName}`) + .sort() + ).toEqual([ + 'calls:app.check_order', + 'references:app.orders', + 'references:app.users', + ]); + }); + + it('extracts partition, inheritance, LIKE, and ALTER relation facts', () => { + const result = extract([ + 'CREATE TABLE app.parent (id bigint);', + 'CREATE TABLE app.template (id bigint);', + 'CREATE TABLE app.child (LIKE app.template INCLUDING ALL) INHERITS (app.parent, audit.parent);', + 'CREATE TABLE app.partition_child PARTITION OF app.parent DEFAULT;', + 'ALTER TABLE app.parent ATTACH PARTITION app.attached DEFAULT;', + 'ALTER TABLE app.parent DETACH PARTITION app.detached CONCURRENTLY;', + 'ALTER TABLE app.child INHERIT audit.base;', + 'ALTER TABLE app.child NO INHERIT app.parent;', + ].join('\n')); + const facts = result.nodes.filter((node) => + node.decorators?.includes(POSTGRES_TABLE_RELATION_DECORATOR) + ); + const descriptors = facts + .map((node) => decodePostgresTableRelationDescriptor(node.decorators)) + .filter((descriptor) => descriptor !== null); + expect(descriptors).toEqual(expect.arrayContaining([ + expect.objectContaining({ relation: 'like', sourceTable: 'app.child', targetTable: 'app.template' }), + expect.objectContaining({ relation: 'inherits', sourceTable: 'app.child', targetTable: 'app.parent' }), + expect.objectContaining({ relation: 'inherits', sourceTable: 'app.child', targetTable: 'audit.parent' }), + expect.objectContaining({ relation: 'partition-of', sourceTable: 'app.partition_child', targetTable: 'app.parent' }), + expect.objectContaining({ relation: 'attach-partition', sourceTable: 'app.attached', targetTable: 'app.parent' }), + expect.objectContaining({ relation: 'detach-partition', sourceTable: 'app.detached', targetTable: 'app.parent', mode: 'concurrently' }), + expect.objectContaining({ relation: 'inherit', sourceTable: 'app.child', targetTable: 'audit.base' }), + expect.objectContaining({ relation: 'no-inherit', sourceTable: 'app.child', targetTable: 'app.parent' }), + ])); + expect(facts).toHaveLength(8); + for (const fact of facts) { + expect(result.unresolvedReferences.filter((ref) => ref.fromNodeId === fact.id)).toHaveLength(2); + } + }); + + it('indexes inline, table-level, and ALTER TABLE foreign-key facts', () => { + const result = extract([ + 'CREATE TABLE app.parents (tenant_id bigint, id bigint, PRIMARY KEY (tenant_id, id));', + 'CREATE TABLE app.children (', + ' tenant_id bigint,', + ' parent_id bigint CONSTRAINT children_parent_inline REFERENCES app.parents(id) ON DELETE SET NULL,', + ' backup_parent_id bigint REFERENCES app.parents(id),', + ' CONSTRAINT children_parent_fk FOREIGN KEY (tenant_id, parent_id)', + ' REFERENCES app.parents(tenant_id, id) MATCH FULL ON UPDATE CASCADE DEFERRABLE INITIALLY DEFERRED', + ');', + 'ALTER TABLE ONLY app.children', + ' ADD CONSTRAINT children_backup_fk FOREIGN KEY (tenant_id, backup_parent_id)', + ' REFERENCES app.parents(tenant_id, id) ON DELETE CASCADE NOT VALID;', + ].join('\n')); + + expect(result.errors).toEqual([]); + const facts = result.nodes + .filter((node) => node.decorators?.includes(POSTGRES_FOREIGN_KEY_DECORATOR)) + .map((node) => ({ + node, + data: decodePostgresForeignKeyDescriptor(node.decorators), + })); + expect(facts).toHaveLength(4); + + const composite = facts.find(({ node }) => node.name === 'children_parent_fk')!; + expect(composite.data).toEqual({ + sourceTable: 'app.children', + targetTable: 'app.parents', + constraintName: 'children_parent_fk', + sourceColumns: ['tenant_id', 'parent_id'], + targetColumns: ['tenant_id', 'id'], + match: 'full', + onUpdate: 'cascade', + deferrable: true, + initially: 'deferred', + }); + + const alter = facts.find(({ node }) => node.name === 'children_backup_fk')!; + expect(alter.data).toEqual({ + sourceTable: 'app.children', + targetTable: 'app.parents', + constraintName: 'children_backup_fk', + sourceColumns: ['tenant_id', 'backup_parent_id'], + targetColumns: ['tenant_id', 'id'], + onDelete: 'cascade', + notValid: true, + }); + for (const { node } of facts) { + expect(result.unresolvedReferences + .filter((ref) => ref.fromNodeId === node.id) + .map((ref) => ref.referenceName) + .sort() + ).toEqual(['app.children', 'app.parents']); + } + }); + + it('keeps same-line anonymous and same-named foreign keys as distinct facts', () => { + const result = extract([ + 'CREATE TABLE app.child (a bigint REFERENCES app.parent_a(id), b bigint REFERENCES app.parent_b(id));', + 'ALTER TABLE app.one ADD CONSTRAINT user_fk FOREIGN KEY (user_id) REFERENCES app.users(id); ALTER TABLE app.two ADD CONSTRAINT user_fk FOREIGN KEY (owner_id) REFERENCES app.users(id);', + ].join('\n')); + + expect(result.errors).toEqual([]); + const facts = result.nodes + .filter((node) => node.decorators?.includes(POSTGRES_FOREIGN_KEY_DECORATOR)) + .map((node) => ({ + id: node.id, + name: node.name, + data: decodePostgresForeignKeyDescriptor(node.decorators), + })); + expect(facts).toHaveLength(4); + expect(new Set(facts.map((fact) => fact.id)).size).toBe(4); + expect(facts.map((fact) => fact.data?.targetTable)).toEqual(expect.arrayContaining([ + 'app.parent_a', + 'app.parent_b', + 'app.users', + 'app.users', + ])); + expect(facts.filter((fact) => fact.name === 'user_fk').map((fact) => fact.data?.sourceTable)) + .toEqual(expect.arrayContaining(['app.one', 'app.two'])); + }); + + it('qualifies unqualified declarations from an explicit single-schema search_path', () => { + const result = extract([ + 'CREATE FUNCTION default_path_fn() RETURNS integer LANGUAGE sql AS $$ SELECT 1 $$;', + 'SET search_path = history;', + 'CREATE TABLE users (id bigint PRIMARY KEY);', + 'SET search_path = public;', + 'CREATE TABLE users (id bigint PRIMARY KEY);', + 'SET search_path = app;', + 'CREATE FUNCTION touch_user() RETURNS trigger LANGUAGE plpgsql AS $$ BEGIN RETURN NEW; END $$;', + ].join('\n')); + + expect(result.errors).toEqual([]); + expect(result.nodes.map((node) => node.qualifiedName)).toEqual(expect.arrayContaining([ + 'history.users', + 'public.users', + 'app.touch_user', + 'public.default_path_fn', + ])); + }); + + it('keeps same-line search_path declarations and their columns distinct', () => { + const result = extract( + 'SET search_path=a; CREATE TABLE users(id int); ' + + 'SET search_path=b; CREATE TABLE users(id int);' + ); + const tables = result.nodes.filter((node) => node.decorators?.includes('postgres:table')); + const columns = result.nodes.filter((node) => node.decorators?.includes('postgres:column')); + + expect(tables.map((node) => node.qualifiedName)).toEqual(['a.users', 'b.users']); + expect(new Set(tables.map((node) => node.id)).size).toBe(2); + expect(columns.map((node) => node.qualifiedName)).toEqual(['a.users.id', 'b.users.id']); + expect(new Set(columns.map((node) => node.id)).size).toBe(2); }); it('models ALTER TABLE ADD COLUMN as a relation-linked migration delta', () => { @@ -161,8 +436,8 @@ describe('PostgreSQL extraction', () => { (node) => node.decorators?.includes('postgres:alter-table-add-column') ); expect(deltas.map((node) => node.qualifiedName).sort()).toEqual([ - 'app.users.ADD COLUMN display_name', - 'app.users.ADD COLUMN email', + 'app.users."ADD COLUMN display_name"', + 'app.users."ADD COLUMN email"', ]); for (const delta of deltas) { @@ -262,4 +537,349 @@ describe('PostgreSQL extraction', () => { fs.rmSync(projectDir, { recursive: true, force: true }); } }); + + it('links cross-migration foreign keys and triggers and removes stale FK edges on sync', async () => { + const projectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-postgres-relations-')); + const relationsPath = path.join(projectDir, '004_relations.sql'); + fs.writeFileSync( + path.join(projectDir, '001_users.sql'), + 'CREATE TABLE app.users (id bigint PRIMARY KEY);\n' + ); + fs.writeFileSync( + path.join(projectDir, '002_orders.sql'), + 'CREATE TABLE app.orders (id bigint PRIMARY KEY, user_id bigint);\n' + ); + fs.writeFileSync( + path.join(projectDir, '003_touch.sql'), + "CREATE FUNCTION app.touch_user() RETURNS trigger LANGUAGE plpgsql AS 'BEGIN RETURN NEW; END';\n" + ); + const triggerSql = + 'CREATE TRIGGER users_touch AFTER UPDATE ON app.users EXECUTE FUNCTION app.touch_user();\n'; + const foreignKeySql = [ + 'ALTER TABLE app.orders ADD CONSTRAINT orders_user_fk', + ' FOREIGN KEY (user_id) REFERENCES app.users(id) ON DELETE CASCADE;', + ].join('\n') + '\n'; + fs.writeFileSync(relationsPath, foreignKeySql + triggerSql); + + const graph = CodeGraph.initSync(projectDir); + try { + await graph.indexAll(); + const users = graph.getNodesByName('users').find((node) => node.qualifiedName === 'app.users')!; + const orders = graph.getNodesByName('orders').find((node) => node.qualifiedName === 'app.orders')!; + const routine = graph.getNodesByName('touch_user').find( + (node) => node.decorators?.includes('postgres:function') + )!; + const trigger = graph.getNodesByName('users_touch').find( + (node) => node.decorators?.includes('postgres:trigger') + )!; + + const fkEdge = graph.getOutgoingEdges(orders.id).find((edge) => + edge.target === users.id && edge.metadata?.postgresRelation === 'foreign-key' + ); + expect(fkEdge).toBeTruthy(); + expect(fkEdge!.provenance).toBe('tree-sitter'); + expect(fkEdge!.metadata?.constraints).toEqual([ + expect.objectContaining({ + constraintName: 'orders_user_fk', + sourceColumns: ['user_id'], + targetColumns: ['id'], + onDelete: 'cascade', + filePath: '004_relations.sql', + }), + ]); + + expect(graph.getIncomingEdges(users.id)).toEqual(expect.arrayContaining([ + expect.objectContaining({ source: orders.id, kind: 'references' }), + expect.objectContaining({ source: trigger.id, kind: 'references' }), + ])); + expect(graph.getOutgoingEdges(trigger.id)).toEqual(expect.arrayContaining([ + expect.objectContaining({ target: users.id, kind: 'references' }), + expect.objectContaining({ target: routine.id, kind: 'calls' }), + ])); + + graph.clear(); + await graph.indexAll(); + expect(graph.getOutgoingEdges(orders.id).some((edge) => + edge.target === users.id && edge.metadata?.postgresRelation === 'foreign-key' + )).toBe(true); + + // Simulate a process dying after the store phase of a pure removal but + // before FK synthesis. The source/target tables survive, so the direct + // edge is intentionally stale while the persisted fact fingerprint is + // old; the next no-change sync must detect and recover it. + fs.unlinkSync(relationsPath); + await (graph as any).orchestrator.sync(); + expect(graph.getOutgoingEdges(orders.id).some((edge) => + edge.target === users.id && edge.metadata?.postgresRelation === 'foreign-key' + )).toBe(true); + + await graph.sync(); + expect(graph.getOutgoingEdges(orders.id).some((edge) => + edge.target === users.id && edge.metadata?.postgresRelation === 'foreign-key' + )).toBe(false); + } finally { + graph.destroy(); + fs.rmSync(projectDir, { recursive: true, force: true }); + } + }); + + it('removes an FK projection when a target table becomes a view', async () => { + const projectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-postgres-fk-target-')); + const usersPath = path.join(projectDir, '001_users.sql'); + fs.writeFileSync(usersPath, 'CREATE TABLE app.users (id bigint PRIMARY KEY);\n'); + fs.writeFileSync( + path.join(projectDir, '002_orders.sql'), + 'CREATE TABLE app.orders (id bigint, user_id bigint REFERENCES app.users(id));\n' + ); + + const graph = CodeGraph.initSync(projectDir); + try { + await graph.indexAll(); + const users = graph.getNodesByQualifiedName('app.users')[0]!; + const orders = graph.getNodesByQualifiedName('app.orders')[0]!; + expect(graph.getOutgoingEdges(orders.id).some((edge) => + edge.target === users.id && edge.metadata?.postgresRelation === 'foreign-key' + )).toBe(true); + + fs.writeFileSync(usersPath, 'CREATE VIEW app.users AS SELECT 1::bigint AS id;\n'); + await graph.sync(); + const view = graph.getNodesByQualifiedName('app.users')[0]!; + expect(view.decorators).toContain('postgres:view'); + expect(graph.getOutgoingEdges(orders.id).some((edge) => + edge.target === view.id && edge.metadata?.postgresRelation === 'foreign-key' + )).toBe(false); + } finally { + graph.destroy(); + fs.rmSync(projectDir, { recursive: true, force: true }); + } + }); + + it('does not replace FK edges for an unrelated TypeScript-only sync', async () => { + const projectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-postgres-fk-noop-')); + fs.writeFileSync( + path.join(projectDir, 'schema.sql'), + [ + 'CREATE TABLE app.users (id bigint PRIMARY KEY);', + 'CREATE TABLE app.orders (user_id bigint REFERENCES app.users(id));', + ].join('\n') + ); + const tsPath = path.join(projectDir, 'app.ts'); + fs.writeFileSync(tsPath, 'export const value = 1;\n'); + + const graph = CodeGraph.initSync(projectDir); + try { + await graph.indexAll(); + const queries = (graph as any).queries; + const plan = (graph as any).db.getDb().prepare(` + EXPLAIN QUERY PLAN + SELECT source FROM edges + WHERE json_extract(CASE WHEN json_valid(metadata) THEN metadata ELSE '{}' END, '$.synthesizedBy') = ? + AND json_extract(CASE WHEN json_valid(metadata) THEN metadata ELSE '{}' END, '$.synthesizedBy') IS NOT NULL + `).all('postgres-foreign-key') as Array<{ detail: string }>; + expect(plan.map((row) => row.detail).join(' ')).toContain('idx_edges_synthesized_by'); + const originalReplace = queries.replaceEdgesBySynthesizer.bind(queries); + let replacements = 0; + queries.replaceEdgesBySynthesizer = (...args: unknown[]) => { + replacements++; + return originalReplace(...args); + }; + + fs.writeFileSync(tsPath, 'export const value = 2;\n'); + await graph.sync(); + expect(replacements).toBe(0); + } finally { + graph.destroy(); + fs.rmSync(projectDir, { recursive: true, force: true }); + } + }); + + it('synthesizes cross-schema FK roles through the synchronous resolution API', async () => { + const projectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-postgres-sync-resolve-')); + fs.writeFileSync( + path.join(projectDir, '001_public.sql'), + 'CREATE TABLE public.users (id bigint PRIMARY KEY);\n' + ); + fs.writeFileSync( + path.join(projectDir, '002_audit.sql'), + 'CREATE TABLE audit.users (id bigint PRIMARY KEY, parent_id bigint);\n' + ); + fs.writeFileSync( + path.join(projectDir, '003_fk.sql'), + [ + 'SET search_path = public;', + 'ALTER TABLE audit.users ADD CONSTRAINT audit_users_parent_fk', + ' FOREIGN KEY (parent_id) REFERENCES users(id);', + '', + ].join('\n') + ); + + const graph = CodeGraph.initSync(projectDir); + try { + await graph.indexFiles(['001_public.sql', '002_audit.sql', '003_fk.sql']); + graph.resolveReferences(); + + const publicUsers = graph.getNodesByQualifiedName('public.users')[0]!; + const auditUsers = graph.getNodesByQualifiedName('audit.users')[0]!; + expect(publicUsers).toBeTruthy(); + expect(auditUsers).toBeTruthy(); + expect(graph.getOutgoingEdges(auditUsers.id)).toEqual(expect.arrayContaining([ + expect.objectContaining({ + target: publicUsers.id, + kind: 'references', + metadata: expect.objectContaining({ postgresRelation: 'foreign-key' }), + }), + ])); + } finally { + graph.destroy(); + fs.rmSync(projectDir, { recursive: true, force: true }); + } + }); + + it('links search_path-qualified declarations and references end to end', async () => { + const projectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-postgres-search-path-')); + fs.writeFileSync( + path.join(projectDir, 'schema.sql'), + [ + 'SET search_path = app;', + 'CREATE TABLE users (id bigint PRIMARY KEY);', + 'CREATE TABLE orders (id bigint, user_id bigint REFERENCES users(id));', + 'CREATE FUNCTION touch_user() RETURNS trigger LANGUAGE plpgsql AS $$ BEGIN RETURN NEW; END $$;', + 'CREATE TRIGGER users_touch AFTER UPDATE ON users EXECUTE FUNCTION touch_user();', + ].join('\n') + ); + + const graph = CodeGraph.initSync(projectDir); + try { + await graph.indexAll(); + const users = graph.getNodesByQualifiedName('app.users')[0]!; + const orders = graph.getNodesByQualifiedName('app.orders')[0]!; + const routine = graph.getNodesByQualifiedName('app.touch_user')[0]!; + expect(users).toBeTruthy(); + expect(orders).toBeTruthy(); + expect(routine).toBeTruthy(); + expect(graph.getOutgoingEdges(orders.id)).toEqual(expect.arrayContaining([ + expect.objectContaining({ + target: users.id, + metadata: expect.objectContaining({ postgresRelation: 'foreign-key' }), + }), + ])); + const trigger = graph.getNodesByName('users_touch')[0]!; + expect(trigger.qualifiedName).toBe('app.users.users_touch'); + expect(graph.getOutgoingEdges(trigger.id)).toEqual(expect.arrayContaining([ + expect.objectContaining({ target: users.id, kind: 'references' }), + expect.objectContaining({ target: routine.id, kind: 'calls' }), + ])); + } finally { + graph.destroy(); + fs.rmSync(projectDir, { recursive: true, force: true }); + } + }); + + it('keeps references distinct when a temporary relation changes the binding', async () => { + const projectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-postgres-temp-order-')); + fs.writeFileSync(path.join(projectDir, 'schema.sql'), [ + 'CREATE TABLE public.sessions (id bigint);', + 'SELECT * FROM sessions;', + 'CREATE TEMP TABLE sessions (id bigint);', + 'SELECT * FROM sessions;', + 'DROP TABLE sessions;', + 'SELECT * FROM sessions;', + ].join('\n')); + + const graph = CodeGraph.initSync(projectDir); + try { + await graph.indexAll(); + const persistent = graph.getNodesByQualifiedName('public.sessions')[0]!; + const temporary = graph.getNodesByQualifiedName('pg_temp.sessions')[0]!; + const file = graph.getNodesByName('schema.sql').find((node) => node.kind === 'file')!; + expect(persistent).toBeTruthy(); + expect(temporary.decorators).toContain('postgres:temporary'); + + const targets = graph.getOutgoingEdges(file.id) + .filter((edge) => edge.kind === 'references') + .map((edge) => edge.target); + expect(targets).toEqual(expect.arrayContaining([persistent.id, temporary.id])); + } finally { + graph.destroy(); + fs.rmSync(projectDir, { recursive: true, force: true }); + } + }); + + it('projects structural table relations and cross-file schema containment end to end', async () => { + const projectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-postgres-structure-')); + fs.writeFileSync(path.join(projectDir, '001_base.sql'), [ + 'CREATE SCHEMA app;', + 'CREATE SCHEMA nested CREATE TABLE things (id bigint);', + 'CREATE TABLE app.parent (id bigint);', + 'CREATE TABLE app.template (id bigint);', + 'CREATE FUNCTION app.check_parent() RETURNS trigger LANGUAGE plpgsql AS $$ BEGIN RETURN NEW; END $$;', + ].join('\n')); + const childPath = path.join(projectDir, '002_children.sql'); + fs.writeFileSync(childPath, [ + 'CREATE TABLE app.child (LIKE app.template INCLUDING ALL) INHERITS (app.parent);', + 'CREATE TABLE app.partition_child PARTITION OF app.parent DEFAULT;', + 'CREATE TABLE app.attached (id bigint);', + 'CREATE TABLE app.detached (id bigint);', + ].join('\n')); + fs.writeFileSync(path.join(projectDir, '003_operations.sql'), [ + 'ALTER TABLE app.parent ATTACH PARTITION app.attached DEFAULT;', + 'ALTER TABLE app.parent DETACH PARTITION app.detached;', + 'CREATE CONSTRAINT TRIGGER child_parent_check AFTER UPDATE ON app.child FROM app.parent', + ' DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION app.check_parent();', + ].join('\n')); + + const graph = CodeGraph.initSync(projectDir); + try { + await graph.indexAll(); + const schema = graph.getNodesByQualifiedName('app')[0]!; + const nestedSchema = graph.getNodesByQualifiedName('nested')[0]!; + const nestedTable = graph.getNodesByQualifiedName('nested.things')[0]!; + const parent = graph.getNodesByQualifiedName('app.parent')[0]!; + const template = graph.getNodesByQualifiedName('app.template')[0]!; + const child = graph.getNodesByQualifiedName('app.child')[0]!; + const partition = graph.getNodesByQualifiedName('app.partition_child')[0]!; + const attached = graph.getNodesByQualifiedName('app.attached')[0]!; + const detached = graph.getNodesByQualifiedName('app.detached')[0]!; + + const expectRelation = (sourceId: string, targetId: string, relation: string) => { + expect(graph.getOutgoingEdges(sourceId)).toEqual(expect.arrayContaining([ + expect.objectContaining({ + target: targetId, + kind: 'references', + metadata: expect.objectContaining({ postgresRelation: relation }), + }), + ])); + }; + expectRelation(child.id, parent.id, 'inherits'); + expectRelation(child.id, template.id, 'like'); + expectRelation(child.id, parent.id, 'constraint-trigger'); + expectRelation(partition.id, parent.id, 'partition-of'); + expectRelation(attached.id, parent.id, 'attach-partition'); + expectRelation(detached.id, parent.id, 'detach-partition'); + + const contained = graph.getOutgoingEdges(schema.id, ['contains']).map((edge) => edge.target); + expect(contained).toEqual(expect.arrayContaining([parent.id, template.id, child.id])); + expect(graph.getOutgoingEdges(nestedSchema.id, ['contains']).filter( + (edge) => edge.target === nestedTable.id + )).toHaveLength(1); + + fs.writeFileSync(childPath, [ + 'CREATE TABLE app.child (LIKE app.template INCLUDING ALL);', + 'CREATE TABLE app.partition_child PARTITION OF app.parent DEFAULT;', + 'CREATE TABLE app.attached (id bigint);', + 'CREATE TABLE app.detached (id bigint);', + ].join('\n')); + await graph.sync(); + const refreshedChild = graph.getNodesByQualifiedName('app.child')[0]!; + expect(graph.getOutgoingEdges(refreshedChild.id).some( + (edge) => edge.metadata?.postgresRelation === 'inherits' + )).toBe(false); + expect(graph.getOutgoingEdges(refreshedChild.id).some( + (edge) => edge.metadata?.postgresRelation === 'like' + )).toBe(true); + } finally { + graph.destroy(); + fs.rmSync(projectDir, { recursive: true, force: true }); + } + }); }); diff --git a/__tests__/postgres-name-matcher.test.ts b/__tests__/postgres-name-matcher.test.ts index e354a2283..775b4da7a 100644 --- a/__tests__/postgres-name-matcher.test.ts +++ b/__tests__/postgres-name-matcher.test.ts @@ -19,6 +19,11 @@ interface NodeOptions { kind?: NodeKind; language?: Language; decorators?: string[]; + signature?: string; + startLine?: number; + endLine?: number; + startColumn?: number; + endColumn?: number; } function makeNode(options: NodeOptions): Node { @@ -30,10 +35,11 @@ function makeNode(options: NodeOptions): Node { kind: options.kind ?? 'struct', language: options.language ?? 'postgres', decorators: options.decorators, - startLine: 1, - endLine: 1, - startColumn: 0, - endColumn: 1, + signature: options.signature, + startLine: options.startLine ?? 1, + endLine: options.endLine ?? options.startLine ?? 1, + startColumn: options.startColumn ?? 0, + endColumn: options.endColumn ?? 1, updatedAt: 0, }; } @@ -54,7 +60,7 @@ function makeRef( }; } -function contextFor(nodes: Node[]): ResolutionContext { +function contextFor(nodes: Node[], sources: Record = {}): ResolutionContext { return { getNodesInFile: (filePath) => nodes.filter((node) => node.filePath === filePath), getNodesByName: (name) => nodes.filter((node) => node.name === name), @@ -62,7 +68,7 @@ function contextFor(nodes: Node[]): ResolutionContext { nodes.filter((node) => node.qualifiedName === qualifiedName), getNodesByKind: (kind) => nodes.filter((node) => node.kind === kind), fileExists: (filePath) => nodes.some((node) => node.filePath === filePath), - readFile: () => null, + readFile: (filePath) => sources[filePath] ?? null, getProjectRoot: () => '/project', getAllFiles: () => [...new Set(nodes.map((node) => node.filePath))], getNodesByLowerName: (lowerName) => @@ -104,6 +110,201 @@ describe('PostgreSQL qualified-name resolution', () => { expect(matchReference(makeRef('public::users'), contextFor([nested]))).toBeNull(); }); + it('distinguishes dots inside quoted identifier segments', () => { + const quotedSchema = makeNode({ + id: 'quoted-schema', + name: 'users', + qualifiedName: '"public.app".users', + filePath: 'migrations/001.sql', + }); + const quotedTable = makeNode({ + id: 'quoted-table', + name: 'app.users', + qualifiedName: 'public."app.users"', + filePath: 'migrations/002.sql', + }); + const context = contextFor([quotedSchema, quotedTable]); + expect(matchReference(makeRef('"public.app".users'), context)) + .toMatchObject({ targetNodeId: quotedSchema.id }); + expect(matchReference(makeRef('public."app.users"'), context)) + .toMatchObject({ targetNodeId: quotedTable.id }); + }); + + it('searches an unqualified quoted-dot name without treating its dot as a separator', () => { + const filePath = 'migrations/003.sql'; + const table = makeNode({ + id: 'versioned-users', + name: 'users.v2', + qualifiedName: 'app."users.v2"', + filePath: 'migrations/001.sql', + }); + const source = 'SET search_path=app; SELECT * FROM "users.v2";'; + expect(matchReference( + { ...makeRef('"users.v2"', filePath), line: 1, column: source.indexOf('"users.v2"') }, + contextFor([table], { [filePath]: source }) + )).toMatchObject({ targetNodeId: table.id }); + }); + + it('prefers same-file pg_temp relations and never leaks them across migration files', () => { + const localFile = 'migrations/003.sql'; + const persistent = makeNode({ + id: 'public-sessions', + name: 'sessions', + qualifiedName: 'public.sessions', + filePath: 'migrations/001.sql', + }); + const temporary = makeNode({ + id: 'temp-sessions', + name: 'sessions', + qualifiedName: 'pg_temp.sessions', + filePath: localFile, + decorators: ['postgres:table', 'postgres:temporary'], + }); + const context = contextFor([persistent, temporary]); + expect(matchReference(makeRef('sessions', localFile), context)) + .toMatchObject({ targetNodeId: temporary.id }); + expect(matchReference(makeRef('public.sessions', localFile), context)) + .toMatchObject({ targetNodeId: persistent.id }); + expect(matchReference(makeRef('sessions', 'migrations/004.sql'), context)) + .toMatchObject({ targetNodeId: persistent.id }); + expect(matchReference(makeRef('pg_temp.sessions', 'migrations/004.sql'), context)).toBeNull(); + }); + + it('honors same-file temporary relation declaration and drop order', () => { + const filePath = 'migrations/003.sql'; + const source = [ + 'SELECT * FROM sessions;', + 'CREATE TEMP TABLE sessions (id bigint);', + 'SELECT * FROM sessions;', + 'DROP TABLE sessions;', + 'SELECT * FROM sessions;', + ].join('\n'); + const persistent = makeNode({ + id: 'public-sessions', + name: 'sessions', + qualifiedName: 'public.sessions', + filePath: 'migrations/001.sql', + }); + const temporary = makeNode({ + id: 'temp-sessions', + name: 'sessions', + qualifiedName: 'pg_temp.sessions', + filePath, + decorators: ['postgres:table', 'postgres:temporary'], + startLine: 2, + endLine: 2, + endColumn: source.split('\n')[1]!.length - 1, + }); + const context = contextFor([persistent, temporary], { [filePath]: source }); + const atLine = (line: number) => matchReference( + { ...makeRef('sessions', filePath), line, column: source.split('\n')[line - 1]!.indexOf('sessions') }, + context + ); + + expect(atLine(1)).toMatchObject({ targetNodeId: persistent.id }); + expect(atLine(3)).toMatchObject({ targetNodeId: temporary.id }); + expect(atLine(5)).toMatchObject({ targetNodeId: persistent.id }); + }); + + it('applies ON COMMIT DROP and rolls transactional DROP back', () => { + const filePath = 'migrations/003.sql'; + const source = [ + 'BEGIN;', + 'CREATE TEMP TABLE sessions (id bigint) ON COMMIT DROP;', + 'SELECT * FROM sessions;', + 'COMMIT;', + 'SELECT * FROM sessions;', + 'CREATE TEMP TABLE scratch (id bigint);', + 'BEGIN;', + 'DROP TABLE scratch;', + 'SELECT * FROM scratch;', + 'ROLLBACK;', + 'SELECT * FROM scratch;', + 'BEGIN;', + 'SAVEPOINT keep_scratch;', + 'DROP TABLE scratch;', + 'ROLLBACK TO SAVEPOINT keep_scratch;', + 'SELECT * FROM scratch;', + 'SAVEPOINT before_later;', + 'CREATE TEMP TABLE later (id bigint);', + 'ROLLBACK TO before_later;', + 'SELECT * FROM later;', + 'COMMIT;', + ].join('\n'); + const persistentSessions = makeNode({ + id: 'public-sessions', + name: 'sessions', + qualifiedName: 'public.sessions', + filePath: 'migrations/001.sql', + }); + const persistentScratch = makeNode({ + id: 'public-scratch', + name: 'scratch', + qualifiedName: 'public.scratch', + filePath: 'migrations/001.sql', + }); + const persistentLater = makeNode({ + id: 'public-later', + name: 'later', + qualifiedName: 'public.later', + filePath: 'migrations/001.sql', + }); + const temporarySessions = makeNode({ + id: 'temp-sessions', + name: 'sessions', + qualifiedName: 'pg_temp.sessions', + filePath, + decorators: ['postgres:table', 'postgres:temporary'], + startLine: 2, + endLine: 2, + endColumn: source.split('\n')[1]!.length - 1, + signature: 'CREATE TEMP TABLE sessions (id bigint) ON COMMIT DROP', + }); + const temporaryScratch = makeNode({ + id: 'temp-scratch', + name: 'scratch', + qualifiedName: 'pg_temp.scratch', + filePath, + decorators: ['postgres:table', 'postgres:temporary'], + startLine: 6, + endLine: 6, + endColumn: source.split('\n')[5]!.length - 1, + }); + const temporaryLater = makeNode({ + id: 'temp-later', + name: 'later', + qualifiedName: 'pg_temp.later', + filePath, + decorators: ['postgres:table', 'postgres:temporary'], + startLine: 18, + endLine: 18, + endColumn: source.split('\n')[17]!.length - 1, + }); + const context = contextFor( + [ + persistentSessions, + persistentScratch, + persistentLater, + temporarySessions, + temporaryScratch, + temporaryLater, + ], + { [filePath]: source } + ); + const resolveAt = (name: string, line: number) => matchReference({ + ...makeRef(name, filePath), + line, + column: source.split('\n')[line - 1]!.indexOf(name), + }, context); + + expect(resolveAt('sessions', 3)).toMatchObject({ targetNodeId: temporarySessions.id }); + expect(resolveAt('sessions', 5)).toMatchObject({ targetNodeId: persistentSessions.id }); + expect(resolveAt('scratch', 9)).toMatchObject({ targetNodeId: persistentScratch.id }); + expect(resolveAt('scratch', 11)).toMatchObject({ targetNodeId: temporaryScratch.id }); + expect(resolveAt('scratch', 16)).toMatchObject({ targetNodeId: temporaryScratch.id }); + expect(resolveAt('later', 20)).toMatchObject({ targetNodeId: persistentLater.id }); + }); + it('prefers one exact same-file revision over duplicate historical definitions', () => { const historical = makeNode({ id: 'users-v1', @@ -197,10 +398,10 @@ describe('PostgreSQL unqualified-name resolution', () => { .toMatchObject({ targetNodeId: users.id }); }); - it('does not pick a path-proximate object when an unqualified name is ambiguous', () => { + it('uses PostgreSQL default public before same-named objects in other schemas', () => { const nodes = [ makeNode({ - id: 'near-users', + id: 'public-users', name: 'users', qualifiedName: 'public::users', filePath: 'migrations/002_near.sql', @@ -213,9 +414,467 @@ describe('PostgreSQL unqualified-name resolution', () => { }), ]; + expect(matchReference(makeRef('users'), contextFor(nodes))) + .toMatchObject({ targetNodeId: 'public-users' }); + }); + + it('preserves ambiguity in the first matching schema over a legacy fallback', () => { + const nodes = [ + makeNode({ + id: 'public-users-v1', + name: 'users', + qualifiedName: 'public.users', + filePath: 'migrations/001_public.sql', + }), + makeNode({ + id: 'public-users-v2', + name: 'users', + qualifiedName: 'public.users', + filePath: 'migrations/002_public.sql', + }), + makeNode({ + id: 'legacy-users', + name: 'users', + qualifiedName: 'users', + filePath: 'migrations/000_legacy.sql', + }), + ]; + + expect(matchReference(makeRef('users'), contextFor(nodes))).toBeNull(); + }); + + it('does not pick a path-proximate object when no search-path schema matches', () => { + const nodes = [ + makeNode({ + id: 'auth-users', + name: 'users', + qualifiedName: 'auth::users', + filePath: 'migrations/002_near.sql', + }), + makeNode({ + id: 'history-users', + name: 'users', + qualifiedName: 'history::users', + filePath: 'schemas/history/001.sql', + }), + ]; + expect(matchReference(makeRef('users'), contextFor(nodes))).toBeNull(); }); + it('does not resolve a unique relation outside the default search path', () => { + const authUsers = makeNode({ + id: 'auth-users', + name: 'users', + qualifiedName: 'auth.users', + filePath: 'migrations/001_auth.sql', + }); + + expect(matchReference(makeRef('users'), contextFor([authUsers]))).toBeNull(); + }); + + it('honors the active SET search_path before the reference line', () => { + const filePath = 'migrations/003_consumer.sql'; + const nodes = [ + makeNode({ + id: 'public-users', + name: 'users', + qualifiedName: 'public.users', + filePath: 'migrations/001_public.sql', + }), + makeNode({ + id: 'history-users', + name: 'users', + qualifiedName: 'history.users', + filePath: 'migrations/001_history.sql', + }), + ]; + const source = 'SET search_path TO history, public;\n\nSELECT * FROM users;\n'; + + expect(matchReference(makeRef('users', filePath), contextFor(nodes, { [filePath]: source }))) + .toMatchObject({ targetNodeId: 'history-users' }); + }); + + it('does not invent a public fallback after an explicitly empty search_path', () => { + const filePath = 'migrations/003_consumer.sql'; + const publicUsers = makeNode({ + id: 'public-users', + name: 'users', + qualifiedName: 'public.users', + filePath: 'migrations/001_public.sql', + }); + const source = "SELECT pg_catalog.set_config('search_path', '', false);\nSELECT * FROM users;\n"; + + expect(matchReference( + makeRef('users', filePath), + contextFor([publicUsers], { [filePath]: source }) + )).toBeNull(); + }); + + it('decodes quoted SET values and preserves same-line statement order', () => { + const filePath = 'migrations/003_consumer.sql'; + const historyUsers = makeNode({ + id: 'history-users', + name: 'users', + qualifiedName: 'history.users', + filePath: 'migrations/001_history.sql', + }); + const source = "SET search_path = 'history'; SELECT * FROM users;\r\n"; + const ref = { + ...makeRef('users', filePath), + line: 1, + column: source.indexOf('users'), + }; + + expect(matchReference(ref, contextFor([historyUsers], { [filePath]: source }))) + .toMatchObject({ targetNodeId: 'history-users' }); + }); + + it('preserves case and commas in SET string-literal schema names', () => { + const filePath = 'migrations/003_consumer.sql'; + const nodes = [ + makeNode({ + id: 'camel-users', + name: 'users', + qualifiedName: '"CamelSchema".users', + filePath: 'migrations/001_camel.sql', + }), + makeNode({ + id: 'comma-users', + name: 'users', + qualifiedName: '"a,b, public".users', + filePath: 'migrations/001_comma.sql', + }), + ]; + + for (const [source, targetNodeId] of [ + ["SET search_path = 'CamelSchema'; SELECT * FROM users;", 'camel-users'], + ["SET search_path = 'a,b, public'; SELECT * FROM users;", 'comma-users'], + ] as const) { + expect(matchReference( + { ...makeRef('users', filePath), line: 1, column: source.indexOf('users') }, + contextFor(nodes, { [filePath]: source }) + )).toMatchObject({ targetNodeId }); + } + }); + + it('treats SET SCHEMA literals as a one-element search path', () => { + const filePath = 'migrations/003_consumer.sql'; + const nodes = [ + makeNode({ + id: 'history-users', + name: 'users', + qualifiedName: 'history.users', + filePath: 'migrations/001_history.sql', + }), + makeNode({ + id: 'camel-users', + name: 'users', + qualifiedName: '"CamelSchema".users', + filePath: 'migrations/001_camel.sql', + }), + makeNode({ + id: 'comma-users', + name: 'users', + qualifiedName: '"a,b".users', + filePath: 'migrations/001_comma.sql', + }), + ]; + + for (const [source, targetNodeId] of [ + ["set schema 'history'; SELECT * FROM users;", 'history-users'], + ["SET SESSION SCHEMA 'CamelSchema'; SELECT * FROM users;", 'camel-users'], + ["SeT ScHeMa 'a,b'; SELECT * FROM users;", 'comma-users'], + ] as const) { + expect(matchReference( + { ...makeRef('users', filePath), line: 1, column: source.indexOf('users') }, + contextFor(nodes, { [filePath]: source }) + )).toMatchObject({ targetNodeId }); + } + }); + + it('applies SET LOCAL SCHEMA only inside its transaction', () => { + const filePath = 'migrations/003_consumer.sql'; + const nodes = [ + makeNode({ + id: 'public-users', + name: 'users', + qualifiedName: 'public.users', + filePath: 'migrations/001_public.sql', + }), + makeNode({ + id: 'history-users', + name: 'users', + qualifiedName: 'history.users', + filePath: 'migrations/001_history.sql', + }), + ]; + const source = [ + "SET LOCAL SCHEMA 'history'; SELECT * FROM users;", + "BEGIN; SET LOCAL SCHEMA 'history'; SELECT * FROM users; COMMIT;", + 'SELECT * FROM users;', + ].join('\n'); + const first = source.indexOf('users'); + const second = source.indexOf('users', first + 1); + const context = contextFor(nodes, { [filePath]: source }); + + expect(matchReference( + { ...makeRef('users', filePath), line: 1, column: first }, + context + )).toMatchObject({ targetNodeId: 'public-users' }); + expect(matchReference( + { ...makeRef('users', filePath), line: 2, column: second - source.indexOf('\n') - 1 }, + context + )).toMatchObject({ targetNodeId: 'history-users' }); + expect(matchReference( + { ...makeRef('users', filePath), line: 3, column: 14 }, + context + )).toMatchObject({ targetNodeId: 'public-users' }); + }); + + it('rolls back a session-level SET SCHEMA issued in a transaction', () => { + const filePath = 'migrations/003_consumer.sql'; + const nodes = [ + makeNode({ + id: 'public-users', + name: 'users', + qualifiedName: 'public.users', + filePath: 'migrations/001_public.sql', + }), + makeNode({ + id: 'history-users', + name: 'users', + qualifiedName: 'history.users', + filePath: 'migrations/001_history.sql', + }), + ]; + const source = "BEGIN; SET SESSION SCHEMA 'history'; SELECT * FROM users; " + + 'ROLLBACK; SELECT * FROM users;'; + const context = contextFor(nodes, { [filePath]: source }); + + expect(matchReference( + { ...makeRef('users', filePath), line: 1, column: source.indexOf('users') }, + context + )).toMatchObject({ targetNodeId: 'history-users' }); + expect(matchReference( + { ...makeRef('users', filePath), line: 1, column: source.lastIndexOf('users') }, + context + )).toMatchObject({ targetNodeId: 'public-users' }); + }); + + it('supports dollar-quoted SET values without mistaking $ inside identifiers', () => { + const filePath = 'migrations/003_consumer.sql'; + const nodes = [ + makeNode({ + id: 'camel-users', + name: 'users', + qualifiedName: '"CamelSchema".users', + filePath: 'migrations/001_camel.sql', + }), + makeNode({ + id: 'history-users', + name: 'users', + qualifiedName: 'history.users', + filePath: 'migrations/001_history.sql', + }), + ]; + const dollar = 'SET search_path = $$CamelSchema$$; SELECT * FROM users;'; + const identifier = [ + 'CREATE TABLE foo$tag$bar(id int);', + 'SET search_path = history;', + 'SELECT * FROM users;', + ].join('\n'); + + expect(matchReference( + { ...makeRef('users', filePath), line: 1, column: dollar.indexOf('users') }, + contextFor(nodes, { [filePath]: dollar }) + )).toMatchObject({ targetNodeId: 'camel-users' }); + expect(matchReference( + { ...makeRef('users', filePath), line: 3, column: 14 }, + contextFor(nodes, { [filePath]: identifier }) + )).toMatchObject({ targetNodeId: 'history-users' }); + }); + + it('resumes SQL parsing after a pg_dump COPY FROM STDIN payload', () => { + const filePath = 'migrations/dump.sql'; + const historyUsers = makeNode({ + id: 'history-users', + name: 'users', + qualifiedName: 'history.users', + filePath: 'migrations/001_history.sql', + }); + const source = [ + 'COPY public.seed FROM stdin;', + '1;not SQL', + '\\.', + 'SET search_path = history;', + 'SELECT * FROM users;', + ].join('\n'); + + expect(matchReference( + { ...makeRef('users', filePath), line: 5, column: 14 }, + contextFor([historyUsers], { [filePath]: source }) + )).toMatchObject({ targetNodeId: 'history-users' }); + }); + + it('tracks explicit transaction-local paths and rollback restoration', () => { + const filePath = 'migrations/003_consumer.sql'; + const nodes = [ + makeNode({ + id: 'public-users', + name: 'users', + qualifiedName: 'public.users', + filePath: 'migrations/001_public.sql', + }), + makeNode({ + id: 'history-users', + name: 'users', + qualifiedName: 'history.users', + filePath: 'migrations/001_history.sql', + }), + ]; + for (const terminator of ['COMMIT', 'ROLLBACK'] as const) { + const source = terminator === 'COMMIT' + ? 'BEGIN; SET LOCAL search_path=history; SELECT * FROM users; COMMIT; SELECT * FROM users;' + : 'BEGIN; SET search_path=history; SELECT * FROM users; ROLLBACK; SELECT * FROM users;'; + const first = source.indexOf('users'); + const second = source.lastIndexOf('users'); + const context = contextFor(nodes, { [filePath]: source }); + expect(matchReference( + { ...makeRef('users', filePath), line: 1, column: first }, + context + )).toMatchObject({ targetNodeId: 'history-users' }); + expect(matchReference( + { ...makeRef('users', filePath), line: 1, column: second }, + context + )).toMatchObject({ targetNodeId: 'public-users' }); + } + }); + + it('restores search_path state when rolling back to a savepoint', () => { + const filePath = 'migrations/003_consumer.sql'; + const nodes = [ + makeNode({ + id: 'public-users', + name: 'users', + qualifiedName: 'public.users', + filePath: 'migrations/001_public.sql', + }), + makeNode({ + id: 'history-users', + name: 'users', + qualifiedName: 'history.users', + filePath: 'migrations/001_history.sql', + }), + ]; + for (const set of ['SET search_path=history', 'SET LOCAL search_path=history']) { + const source = `BEGIN; ${set}; SAVEPOINT s; SET LOCAL search_path=public; ` + + 'ROLLBACK WORK TO SAVEPOINT s; SELECT * FROM users;'; + expect(matchReference( + { ...makeRef('users', filePath), line: 1, column: source.lastIndexOf('users') }, + contextFor(nodes, { [filePath]: source }) + )).toMatchObject({ targetNodeId: 'history-users' }); + } + }); + + it('keeps SET LOCAL active in transactions started by AND CHAIN', () => { + const filePath = 'migrations/003_consumer.sql'; + const nodes = [ + makeNode({ + id: 'public-users', + name: 'users', + qualifiedName: 'public.users', + filePath: 'migrations/001_public.sql', + }), + makeNode({ + id: 'history-users', + name: 'users', + qualifiedName: 'history.users', + filePath: 'migrations/001_history.sql', + }), + ]; + for (const terminator of ['COMMIT AND CHAIN', 'ROLLBACK AND CHAIN']) { + const source = 'BEGIN; SET search_path=history; ' + terminator + + '; SET LOCAL search_path=public; SELECT * FROM users;'; + expect(matchReference( + { ...makeRef('users', filePath), line: 1, column: source.lastIndexOf('users') }, + contextFor(nodes, { [filePath]: source }) + )).toMatchObject({ targetNodeId: 'public-users' }); + } + }); + + it('treats a quoted empty SET value as an explicitly empty path', () => { + const filePath = 'migrations/003_consumer.sql'; + const publicUsers = makeNode({ + id: 'public-users', + name: 'users', + qualifiedName: 'public.users', + filePath: 'migrations/001_public.sql', + }); + const source = "SET search_path = '';\r\nSELECT * FROM users;\r\n"; + + expect(matchReference( + { ...makeRef('users', filePath), line: 2, column: 14 }, + contextFor([publicUsers], { [filePath]: source }) + )).toBeNull(); + }); + + it('ignores transaction-local search_path changes', () => { + const filePath = 'migrations/003_consumer.sql'; + const nodes = [ + makeNode({ + id: 'public-users', + name: 'users', + qualifiedName: 'public.users', + filePath: 'migrations/001_public.sql', + }), + makeNode({ + id: 'history-users', + name: 'users', + qualifiedName: 'history.users', + filePath: 'migrations/001_history.sql', + }), + ]; + + for (const source of [ + 'SET LOCAL search_path = history;\nSELECT * FROM users;\n', + "SELECT set_config('search_path', 'history', true);\nSELECT * FROM users;\n", + ]) { + expect(matchReference( + { ...makeRef('users', filePath), line: 2, column: 14 }, + contextFor(nodes, { [filePath]: source }) + )).toMatchObject({ targetNodeId: 'public-users' }); + } + }); + + it('ignores comments, function bodies, and CREATE FUNCTION SET clauses', () => { + const filePath = 'migrations/003_consumer.sql'; + const publicUsers = makeNode({ + id: 'public-users', + name: 'users', + qualifiedName: 'public.users', + filePath: 'migrations/001_public.sql', + }); + const source = [ + '-- SET search_path = history;', + '/* SET search_path = history; */', + "SELECT 'path\\';", + 'CREATE FUNCTION private.f() RETURNS void', + 'LANGUAGE plpgsql SET search_path = \'\'', + 'AS $body$', + 'BEGIN', + ' SET search_path = history;', + 'END', + '$body$;', + 'SELECT * FROM users;', + ].join('\n'); + + expect(matchReference( + { ...makeRef('users', filePath), line: 11, column: 14 }, + contextFor([publicUsers], { [filePath]: source }) + )).toMatchObject({ targetNodeId: 'public-users' }); + }); + it('does not fuzzy-match case variants', () => { const users = makeNode({ id: 'users', diff --git a/__tests__/pr19-improvements.test.ts b/__tests__/pr19-improvements.test.ts index 6dbd20738..e233095eb 100644 --- a/__tests__/pr19-improvements.test.ts +++ b/__tests__/pr19-improvements.test.ts @@ -299,7 +299,7 @@ describe('Best-Candidate Resolution', () => { describe('Schema v2 Migration', () => { it.skipIf(!HAS_SQLITE)('should have correct current schema version', async () => { const { CURRENT_SCHEMA_VERSION } = await import('../src/db/migrations'); - expect(CURRENT_SCHEMA_VERSION).toBe(8); + expect(CURRENT_SCHEMA_VERSION).toBe(9); }); it.skipIf(!HAS_SQLITE)('should have migration for version 2', async () => { diff --git a/__tests__/security.test.ts b/__tests__/security.test.ts index 3b3171782..a4e90963b 100644 --- a/__tests__/security.test.ts +++ b/__tests__/security.test.ts @@ -544,7 +544,7 @@ describe('JSON.parse Error Boundaries in DB', () => { INSERT INTO nodes (id, kind, name, qualified_name, file_path, language, start_line, end_line, start_column, end_column, decorators, is_exported, is_async, is_static, is_abstract, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) `).run( - 'test-node-1', 'function', 'myFunc', 'myFunc', 'test.ts', 'typescript', + 'test-node-1', 'function', 'myFunc', 'myFunc', 'test.sql', 'postgres', 1, 5, 0, 0, '{not valid json!!!}', // malformed decorators 0, 0, 0, 0, Date.now() @@ -555,6 +555,9 @@ describe('JSON.parse Error Boundaries in DB', () => { expect(node).not.toBeNull(); expect(node!.name).toBe('myFunc'); expect(node!.decorators).toBeUndefined(); + expect([ + ...queries.iterateDecoratorReferenceState('postgres', 'postgres:foreign-key'), + ]).toEqual([]); db.close(); }); @@ -578,6 +581,10 @@ describe('JSON.parse Error Boundaries in DB', () => { VALUES (?, ?, ?, ?) `).run('node-a', 'node-b', 'calls', 'broken json {{{'); + // Whole-graph relationship refreshes must skip malformed legacy metadata + // while deleting only edges explicitly owned by that synthesizer. + expect(() => queries.replaceEdgesBySynthesizer('postgres-foreign-key', [])).not.toThrow(); + // Should not throw - should return edge with undefined metadata const edges = queries.getOutgoingEdges('node-a'); expect(edges.length).toBe(1); diff --git a/__tests__/symbol-lookup.test.ts b/__tests__/symbol-lookup.test.ts index c81aaabd4..9c3e079c7 100644 --- a/__tests__/symbol-lookup.test.ts +++ b/__tests__/symbol-lookup.test.ts @@ -220,3 +220,177 @@ describe.skipIf(!HAS_SQLITE)('matchesSymbol — dotted lookups (regression for # expect((text.match(/\*\*Location:\*\*/g) || []).length).toBeGreaterThanOrEqual(2); }); }); + +describe.skipIf(!HAS_SQLITE)('PostgreSQL qualified relation lookup', () => { + let projectRoot: string; + let cg: any; + let handler: any; + let findSymbolMatches: (cg: any, s: string) => any[]; + let findAllSymbols: (cg: any, s: string) => { nodes: any[]; note: string }; + let matchesSymbol: (node: any, s: string) => boolean; + + beforeEach(async () => { + projectRoot = tmpRoot(); + fs.writeFileSync( + path.join(projectRoot, 'schema.sql'), + [ + 'CREATE TABLE public.users (id bigint PRIMARY KEY);', + 'CREATE TABLE history.users (id bigint PRIMARY KEY);', + 'CREATE TABLE app.users (id bigint PRIMARY KEY);', + 'CREATE TABLE "App"."Users" (id bigint PRIMARY KEY);', + 'CREATE TABLE public.orders (id bigint PRIMARY KEY, user_id bigint);', + "CREATE FUNCTION public.touch_user() RETURNS trigger LANGUAGE plpgsql AS 'BEGIN RETURN NEW; END';", + 'ALTER TABLE public.orders ADD CONSTRAINT orders_user_fk FOREIGN KEY (user_id) REFERENCES public.users(id);', + 'CREATE TRIGGER users_touch AFTER UPDATE ON users EXECUTE FUNCTION public.touch_user();', + ].join('\n') + ); + fs.writeFileSync(path.join(projectRoot, 'users.ts'), 'export const users = [];\n'); + + const CodeGraph = (await import('../src/index')).default; + const { ToolHandler } = await import('../src/mcp/tools'); + cg = CodeGraph.initSync(projectRoot, { + config: { include: ['**/*.sql', '**/*.ts'], exclude: [] }, + }); + await cg.indexAll(); + handler = new ToolHandler(cg); + findSymbolMatches = (handler as any).findSymbolMatches.bind(handler); + findAllSymbols = (handler as any).findAllSymbols.bind(handler); + matchesSymbol = (handler as any).matchesSymbol.bind(handler); + }); + + afterEach(() => { + handler?.closeAll(); + cg?.destroy(); + rmTree(projectRoot); + }); + + it('uses the exact qualified-name index for schema.table', async () => { + expect(cg.getNodesByQualifiedName('public.users')).toHaveLength(1); + const matches = findSymbolMatches(cg, 'public.users'); + expect(matches.map((node) => node.qualifiedName)).toEqual(['public.users']); + expect(findAllSymbols(cg, 'public.users').nodes.map((node) => node.qualifiedName)) + .toEqual(['public.users']); + expect(findSymbolMatches(cg, 'missing.users')).toEqual([]); + + const response = await handler.execute('codegraph_node', { symbol: 'public.users' }); + const text = response.content?.[0]?.text ?? ''; + expect(text).toContain('**public.users** (table)'); + expect(text).not.toContain('Symbol "public.users" not found'); + expect(text).toContain('**Referenced by foreign keys ←** public.orders'); + expect(text).toContain('[orders_user_fk]'); + expect(text).toContain('**Triggers ←** users_touch → public.touch_user'); + }); + + it('folds unquoted qualified inputs without folding quoted identifiers', async () => { + expect(findSymbolMatches(cg, 'PUBLIC.USERS').map((node) => node.qualifiedName)) + .toEqual(['public.users']); + expect(findAllSymbols(cg, 'PUBLIC.USERS').nodes.map((node) => node.qualifiedName)) + .toEqual(['public.users']); + + expect(findSymbolMatches(cg, 'APP.USERS').map((node) => node.qualifiedName)) + .toEqual(['app.users']); + expect(findSymbolMatches(cg, '"App"."Users"').map((node) => node.qualifiedName)) + .toEqual(['"App"."Users"']); + expect(findAllSymbols(cg, '"App"."Users"').nodes.map((node) => node.qualifiedName)) + .toEqual(['"App"."Users"']); + + const folded = cg.getNodesByQualifiedName('app.users')[0]; + const quoted = cg.getNodesByQualifiedName('"App"."Users"')[0]; + expect(matchesSymbol(folded, 'APP.USERS')).toBe(true); + expect(matchesSymbol(quoted, '"App"."Users"')).toBe(true); + expect(matchesSymbol(quoted, 'App.Users')).toBe(false); + + const response = await handler.execute('codegraph_node', { symbol: 'PUBLIC.USERS' }); + const text = response.content?.[0]?.text ?? ''; + expect(text).toContain('**public.users** (table)'); + expect(text).not.toContain('Symbol "PUBLIC.USERS" not found'); + }); + + it('ranks an exact qualified relation above its triggers', () => { + const results = cg.searchNodes('public.users', { limit: 10 }); + expect(results[0]?.node.qualifiedName).toBe('public.users'); + }); + + it('keeps exact-qualified ranking stable across search pages', () => { + const full = cg.searchNodes('public.users', { limit: 10, offset: 0 }); + const paged = full.map((_: unknown, offset: number) => + cg.searchNodes('public.users', { limit: 1, offset })[0] + ); + expect(full[0]?.node.qualifiedName).toBe('public.users'); + expect(paged.map((result: any) => result?.node.id)) + .toEqual(full.map((result: any) => result.node.id)); + }); + + it('exposes PostgreSQL relation filters through MCP search', async () => { + const response = await handler.execute('codegraph_search', { + query: 'users', + kind: 'struct', + language: 'postgres', + limit: 10, + }); + const text = response.content?.[0]?.text ?? ''; + expect(text).toContain('**public.users** (table)'); + expect(text).toContain('**history.users** (table)'); + expect(text).not.toContain('users.ts'); + }); +}); + +describe.skipIf(!HAS_SQLITE)('search result pagination', () => { + it('paginates one stable globally-rescored candidate set', async () => { + const projectRoot = tmpRoot(); + const { DatabaseConnection } = await import('../src/db'); + const { QueryBuilder } = await import('../src/db/queries'); + const db = DatabaseConnection.initialize(path.join(projectRoot, 'codegraph.db')); + + try { + const queries = new QueryBuilder(db.getDb()); + const variables = Array.from({ length: 101 }, (_, index) => { + const suffix = String(index).padStart(3, '0'); + return { + id: `variable-${suffix}`, + kind: 'variable' as const, + name: `needle${suffix}`, + qualifiedName: `fixture.needle${suffix}`, + filePath: 'fixture.ts', + language: 'typescript' as const, + startLine: index + 1, + endLine: index + 1, + startColumn: 0, + endColumn: 9, + updatedAt: Date.now(), + }; + }); + queries.insertNodes([ + ...variables, + { + id: 'promoted-function', + kind: 'function', + name: 'needle101', + qualifiedName: 'fixture.needle101', + filePath: 'fixture.ts', + language: 'typescript', + startLine: 102, + endLine: 102, + startColumn: 0, + endColumn: 9, + updatedAt: Date.now(), + }, + ]); + + // The function is deliberately inserted after more than the FTS + // minimum candidate count. Its kind bonus should promote it only after + // every page has selected the same raw candidate universe. + const full = queries.searchNodes('needle', { limit: 30 }); + const paged = Array.from({ length: full.length }, (_, offset) => + queries.searchNodes('needle', { limit: 1, offset })[0] + ); + + expect(full[0]?.node.id).toBe('promoted-function'); + expect(paged.map((result) => result?.node.id)) + .toEqual(full.map((result) => result.node.id)); + } finally { + db.close(); + rmTree(projectRoot); + } + }); +}); diff --git a/src/bin/codegraph.ts b/src/bin/codegraph.ts index eefb5d907..852a35a7f 100644 --- a/src/bin/codegraph.ts +++ b/src/bin/codegraph.ts @@ -1095,8 +1095,9 @@ program .option('-p, --path ', 'Project path') .option('-l, --limit ', 'Maximum results', '10') .option('-k, --kind ', 'Filter by node kind (function, class, etc.)') + .option('--language ', 'Filter by source language (for example postgres)') .option('-j, --json', 'Output as JSON') - .action(async (search: string, options: { path?: string; limit?: string; kind?: string; json?: boolean }) => { + .action(async (search: string, options: { path?: string; limit?: string; kind?: string; language?: string; json?: boolean }) => { const projectPath = resolveProjectPath(options.path); try { @@ -1112,6 +1113,7 @@ program const rawResults = cg.searchNodes(search, { limit, kinds: options.kind ? [options.kind as any] : undefined, + languages: options.language ? [options.language as any] : undefined, }); // Mirror the MCP search down-rank so the CLI also surfaces the @@ -1140,10 +1142,18 @@ program for (const result of results) { const node = result.node; const location = `${node.filePath}:${node.startLine}`; + const postgresKind = node.language === 'postgres' + ? node.decorators?.find((decorator: string) => + decorator.startsWith('postgres:') && + !decorator.startsWith('postgres:foreign-key-data:') && + !decorator.startsWith('postgres:table-relation-data:') + )?.slice('postgres:'.length) + : undefined; + const displayName = node.language === 'postgres' ? node.qualifiedName : node.name; console.log( - chalk.cyan(node.kind.padEnd(12)) + - chalk.white(node.name) + chalk.cyan((postgresKind ?? node.kind).padEnd(12)) + + chalk.white(displayName) ); console.log(chalk.dim(` ${location}`)); if (node.signature) { diff --git a/src/db/index.ts b/src/db/index.ts index 1b7a5883b..233f156a6 100644 --- a/src/db/index.ts +++ b/src/db/index.ts @@ -112,9 +112,12 @@ export class DatabaseConnection { runMigrations(db, currentVersion); } - // Self-heal a bulk-load window that never closed (crash between - // beginBulkNodeLoad and endBulkNodeLoad): the FTS triggers are missing and - // nodes_fts is stale. Rebuild + recreate so search stays in sync. + // Self-heal bulk-load windows that never closed. A process can die after + // dropping secondary indexes or FTS triggers but before the corresponding + // endBulk*Load call recreates them. Schema migrations will not help when + // the database already records the current version, so repair the missing + // schema objects explicitly on every reopen. + conn.healBulkLoadIndexes(); conn.healBulkNodeLoad(); return conn; @@ -279,12 +282,13 @@ export class DatabaseConnection { 'idx_edges_source_kind', 'idx_edges_target_kind', 'idx_edges_provenance', + 'idx_edges_synthesized_by', ] as const; /** * Enter bulk-edge-load mode: drop the non-unique edge indexes so the mass * INSERT OR IGNORE stream pays one B-tree (the identity index) instead of - * five — measured 2.8s → 1.1s inserting a 224k-edge resolution set, with + * six — measured 2.8s → 1.1s inserting a 224k-edge resolution set, with * recreation costing ~0.3s. MUST be paired with endBulkEdgeLoad(); a crash * inside the window is healed on the next DatabaseConnection open (schema.sql * re-applies CREATE INDEX IF NOT EXISTS). @@ -319,6 +323,34 @@ export class DatabaseConnection { } } + /** + * Recreate secondary indexes left missing by any interrupted bulk-load + * window. Only indexes deliberately dropped by beginBulk*Load are eligible: + * this keeps open() from silently masking unrelated schema corruption while + * covering the parse, reference-resolution, and edge-load windows together. + */ + private healBulkLoadIndexes(): void { + const expected = new Set([ + ...DatabaseConnection.BULK_PARSE_INDEX_NAMES, + ...DatabaseConnection.BULK_REF_INDEX_NAMES, + ...DatabaseConnection.BULK_EDGE_INDEX_NAMES, + ]); + const rows = this.db + .prepare("SELECT name FROM sqlite_master WHERE type = 'index'") + .all() as Array<{ name: string }>; + const existing = new Set(rows.map((row) => row.name)); + const missing = [...expected].filter((name) => !existing.has(name)); + if (missing.length === 0) return; + + const schemaPath = path.join(__dirname, 'schema.sql'); + const schema = fs.readFileSync(schemaPath, 'utf-8'); + for (const idx of missing) { + const m = schema.match(new RegExp(`CREATE INDEX IF NOT EXISTS ${idx}\\b[^;]*;`)); + if (!m) throw new Error(`schema.sql: index ${idx} not found for bulk-load recovery`); + this.db.exec(m[0]); + } + } + /** Recreate the FTS triggers + rebuild if a bulk-load window never closed. */ private healBulkNodeLoad(): void { const row = this.db diff --git a/src/db/migrations.ts b/src/db/migrations.ts index d083095bb..ef0124d6d 100644 --- a/src/db/migrations.ts +++ b/src/db/migrations.ts @@ -9,7 +9,7 @@ import { SqliteDatabase } from './sqlite-adapter'; /** * Current schema version */ -export const CURRENT_SCHEMA_VERSION = 8; +export const CURRENT_SCHEMA_VERSION = 9; /** * Migration definition @@ -150,6 +150,18 @@ const migrations: Migration[] = [ `); }, }, + { + version: 9, + description: + 'Index synthesized edge ownership so incremental relationship refreshes avoid full edge-table scans', + up: (db) => { + db.exec(` + CREATE INDEX IF NOT EXISTS idx_edges_synthesized_by + ON edges(json_extract(CASE WHEN json_valid(metadata) THEN metadata ELSE '{}' END, '$.synthesizedBy')) + WHERE json_extract(CASE WHEN json_valid(metadata) THEN metadata ELSE '{}' END, '$.synthesizedBy') IS NOT NULL; + `); + }, + }, ]; /** diff --git a/src/db/queries.ts b/src/db/queries.ts index 16b9d5f91..66ea04e81 100644 --- a/src/db/queries.ts +++ b/src/db/queries.ts @@ -50,6 +50,19 @@ function isLowValueFile(filePath: string): boolean { const SQLITE_PARAM_CHUNK_SIZE = 500; +/** + * Non-empty searches apply JS-only scoring bonuses after SQLite returns the + * lexical matches. Every page must therefore rank the same raw candidate set: + * growing that set with `offset + limit` lets a later page discover a newly + * promoted result and causes duplicates/skips. Keep one fixed top-100 result + * window (the same maximum exposed by the MCP search tool); offsets at or past + * the window intentionally return no results. + * + * `searchNodesFTS` over-fetches this by 5x, so the raw FTS universe is also + * fixed (500 rows) before global rescoring. + */ +const SEARCH_RANKING_WINDOW = 100; + /** * Database row types (snake_case from SQLite) */ @@ -213,6 +226,7 @@ export class QueryBuilder { insertEdge?: SqliteStatement; upsertFile?: SqliteStatement; deleteEdgesBySource?: SqliteStatement; + deleteEdgesBySynthesizer?: SqliteStatement; deleteEdgesByTarget?: SqliteStatement; getEdgesBySource?: SqliteStatement; getEdgesByTarget?: SqliteStatement; @@ -1062,6 +1076,14 @@ export class QueryBuilder { } } + /** Stream every node for one language in stable ID order. */ + *iterateNodesByLanguage(language: Language): IterableIterator { + const stmt = this.db.prepare('SELECT * FROM nodes WHERE language = ? ORDER BY id'); + for (const row of stmt.iterate(language)) { + yield rowToNode(row as NodeRow); + } + } + /** * Get all nodes in the database */ @@ -1090,6 +1112,100 @@ export class QueryBuilder { } } + /** + * Stable, single-query state stream for a decorator-owned relationship + * synthesizer. Includes each fact's encoded data and its currently resolved + * reference endpoints, avoiding an N+1 edge lookup merely to decide whether + * an incremental refresh has any work to do. + */ + *iterateDecoratorReferenceState( + language: Language, + decorator: string + ): IterableIterator<{ + nodeId: string; + decorators: string; + targetId: string | null; + edgeMetadata: string | null; + targetQualifiedName: string | null; + targetKind: string | null; + targetLanguage: string | null; + targetDecorators: string | null; + }> { + const stmt = this.db.prepare(` + SELECT + n.id AS node_id, + n.decorators AS decorators, + e.target AS target_id, + e.metadata AS edge_metadata, + target.qualified_name AS target_qualified_name, + target.kind AS target_kind, + target.language AS target_language, + target.decorators AS target_decorators + FROM nodes n + LEFT JOIN edges e ON e.source = n.id AND e.kind = 'references' + LEFT JOIN nodes target ON target.id = e.target + WHERE n.language = ? + AND EXISTS ( + SELECT 1 FROM json_each( + CASE WHEN json_valid(n.decorators) THEN n.decorators ELSE '[]' END + ) + WHERE json_each.value = ? + ) + ORDER BY n.id, e.target, e.id + `); + for (const row of stmt.iterate(language, decorator) as Iterable<{ + node_id: string; + decorators: string; + target_id: string | null; + edge_metadata: string | null; + target_qualified_name: string | null; + target_kind: string | null; + target_language: string | null; + target_decorators: string | null; + }>) { + yield { + nodeId: row.node_id, + decorators: row.decorators, + targetId: row.target_id, + edgeMetadata: row.edge_metadata, + targetQualifiedName: row.target_qualified_name, + targetKind: row.target_kind, + targetLanguage: row.target_language, + targetDecorators: row.target_decorators, + }; + } + } + + /** Stream a synthesizer's indexed owned edge set in stable order. */ + *iterateEdgesBySynthesizer(synthesizedBy: string): IterableIterator<{ + source: string; + target: string; + kind: string; + metadata: string | null; + line: number | null; + col: number | null; + provenance: string | null; + }> { + const stmt = this.db.prepare(` + SELECT source, target, kind, metadata, line, col, provenance + FROM edges + WHERE json_extract(CASE WHEN json_valid(metadata) THEN metadata ELSE '{}' END, '$.synthesizedBy') = ? + AND json_extract(CASE WHEN json_valid(metadata) THEN metadata ELSE '{}' END, '$.synthesizedBy') IS NOT NULL + ORDER BY source, target, kind, IFNULL(line, -1), IFNULL(col, -1) + `); + for (const row of stmt.iterate(synthesizedBy)) { + yield row as { + source: string; + target: string; + kind: string; + metadata: string | null; + line: number | null; + col: number | null; + provenance: string | null; + }; + } + } + /** * Distinct languages present in the files table. One indexed aggregate — * lets the dynamic-edge synthesizers skip passes for languages the project @@ -1162,6 +1278,14 @@ export class QueryBuilder { */ searchNodes(query: string, options: SearchOptions = {}): SearchResult[] { const { limit = 100, offset = 0 } = options; + // Ranking and exact-qualified supplementation happen in this method, after + // the raw FTS query. Non-empty queries must use the same bounded candidate + // universe on every page. A truly empty query is not rescored, so it can + // retain unbounded, name-ordered pagination for callers that enumerate the + // graph (for example sync parity checks). + const candidateLimit = query + ? SEARCH_RANKING_WINDOW + : Math.max(limit, offset + limit); // Parse field-qualified bits out of the raw query (kind:, lang:, // path:, name:). Anything not recognised stays in `text` and goes @@ -1188,16 +1312,16 @@ export class QueryBuilder { // First try FTS5 with prefix matching let results = text - ? this.searchNodesFTS(text, { kinds, languages, limit, offset }) + ? this.searchNodesFTS(text, { kinds, languages, limit: candidateLimit, offset: 0 }) // Over-fetch by 5× when running filter-only (no text). The // post-scoring path: + name: filters can be very selective, so // a smaller multiplier risks returning fewer than `limit` // results despite the DB having plenty of matches. - : this.searchAllByFilters({ kinds, languages, limit: limit * 5 }); + : this.searchAllByFilters({ kinds, languages, limit: candidateLimit * 5 }); // If no FTS results, try LIKE-based substring search if (results.length === 0 && text.length >= 2) { - results = this.searchNodesLike(text, { kinds, languages, limit, offset }); + results = this.searchNodesLike(text, { kinds, languages, limit: candidateLimit, offset: 0 }); } // Final fuzzy fallback: scan all known names and keep those within @@ -1205,7 +1329,7 @@ export class QueryBuilder { // returned nothing AND there's a text portion long enough to be // worth fuzzing (1-char queries would match too much). if (results.length === 0 && text.length >= 3) { - results = this.searchNodesFuzzy(text, { kinds, languages, limit }); + results = this.searchNodesFuzzy(text, { kinds, languages, limit: candidateLimit }); } // Supplement: ensure exact name matches are always candidates. @@ -1229,7 +1353,7 @@ export class QueryBuilder { sql += ` AND language IN (${languages.map(() => '?').join(',')})`; params.push(...languages); } - sql += ' LIMIT 20'; + sql += ' ORDER BY id LIMIT 20'; const rows = this.db.prepare(sql).all(...params) as NodeRow[]; for (const row of rows) { if (!existingIds.has(row.id)) { @@ -1240,6 +1364,28 @@ export class QueryBuilder { } } + // A fully-qualified symbol is the strongest possible lexical match, but + // FTS tokenizes its separators and heavily weights the simple-name column. + // That can rank `public.users.some_trigger` above the exact `public.users` + // table, or cap the exact node out entirely. Probe the indexed qualified + // name literally and retain its IDs for an explicit scoring bonus. + const exactQualifiedIds = new Set(); + if (text && /[.\/]|::/.test(text)) { + const exactQualified = this.getNodesByQualifiedNameExact(text).filter((node) => + (!kinds || kinds.length === 0 || kinds.includes(node.kind)) && + (!languages || languages.length === 0 || languages.includes(node.language)) + ); + const existingIds = new Set(results.map((result) => result.node.id)); + const maxScore = results.length > 0 ? Math.max(...results.map((result) => result.score)) : 1; + for (const node of exactQualified) { + exactQualifiedIds.add(node.id); + if (!existingIds.has(node.id)) { + results.push({ node, score: maxScore }); + existingIds.add(node.id); + } + } + } + // Apply multi-signal scoring if (results.length > 0 && (text || query)) { const scoringQuery = text || query; @@ -1248,12 +1394,13 @@ export class QueryBuilder { score: r.score + kindBonus(r.node.kind) + scorePathRelevance(r.node.filePath, scoringQuery, this.projectNameTokens) - + nameMatchBonus(r.node.name, scoringQuery), + + nameMatchBonus(r.node.name, scoringQuery) + + (exactQualifiedIds.has(r.node.id) ? 50 : 0), })); - results.sort((a, b) => b.score - a.score); - // Trim to requested limit after rescoring - if (results.length > limit) { - results = results.slice(0, limit); + results.sort((a, b) => b.score - a.score || a.node.id.localeCompare(b.node.id)); + // Trim to the fixed ranking window after rescoring. + if (results.length > candidateLimit) { + results = results.slice(0, candidateLimit); } } @@ -1276,7 +1423,7 @@ export class QueryBuilder { }); } - return results; + return results.slice(offset, offset + limit); } /** @@ -1301,7 +1448,7 @@ export class QueryBuilder { sql += ` AND language IN (${languages.map(() => '?').join(',')})`; params.push(...languages); } - sql += ' ORDER BY name LIMIT ?'; + sql += ' ORDER BY name, id LIMIT ?'; params.push(limit); const rows = this.db.prepare(sql).all(...params) as NodeRow[]; return rows.map((row) => ({ node: rowToNode(row), score: 1 })); @@ -1333,7 +1480,7 @@ export class QueryBuilder { const dist = boundedEditDistance(name.toLowerCase(), lowered, maxDist); if (dist <= maxDist) candidates.push({ name, dist }); } - candidates.sort((a, b) => a.dist - b.dist); + candidates.sort((a, b) => a.dist - b.dist || a.name.localeCompare(b.name)); // Cap the per-name follow-up queries. Each survivor triggers a // separate `SELECT * FROM nodes WHERE name = ?`; without this cap @@ -1357,7 +1504,7 @@ export class QueryBuilder { sql += ` AND language IN (${languages.map(() => '?').join(',')})`; params.push(...languages); } - sql += ' LIMIT 5'; + sql += ' ORDER BY id LIMIT 5'; const rows = this.db.prepare(sql).all(...params) as NodeRow[]; for (const row of rows) { if (seen.has(row.id)) continue; @@ -1424,7 +1571,7 @@ export class QueryBuilder { params.push(...languages); } - sql += ' ORDER BY score LIMIT ? OFFSET ?'; + sql += ' ORDER BY score, nodes.id LIMIT ? OFFSET ?'; params.push(ftsLimit, offset); try { @@ -1488,7 +1635,7 @@ export class QueryBuilder { params.push(...languages); } - sql += ' ORDER BY score DESC, length(name) ASC LIMIT ? OFFSET ?'; + sql += ' ORDER BY score DESC, length(name) ASC, nodes.id ASC LIMIT ? OFFSET ?'; params.push(limit, offset); const rows = this.db.prepare(sql).all(...params) as (NodeRow & { score: number })[]; @@ -1710,6 +1857,50 @@ export class QueryBuilder { this.stmts.deleteEdgesBySource.run(sourceId); } + /** + * Replace one synthesizer's complete edge set in a transaction. Cross-file + * edges are not owned by either endpoint file, so incremental sync rebuilds + * them as a set; the transaction prevents a failed insert leaving a partial + * graph that a no-change sync would not revisit. + */ + replaceEdgesBySynthesizer(synthesizedBy: string, edges: Edge[]): void { + if (!this.stmts.deleteEdgesBySynthesizer) { + this.stmts.deleteEdgesBySynthesizer = this.db.prepare( + "DELETE FROM edges WHERE " + + "json_extract(CASE WHEN json_valid(metadata) THEN metadata ELSE '{}' END, '$.synthesizedBy') = ? " + + "AND json_extract(CASE WHEN json_valid(metadata) THEN metadata ELSE '{}' END, '$.synthesizedBy') IS NOT NULL" + ); + } + this.db.transaction(() => { + this.stmts.deleteEdgesBySynthesizer!.run(synthesizedBy); + const endpointIds = new Set(); + for (const edge of edges) { + endpointIds.add(edge.source); + endpointIds.add(edge.target); + } + const existingNodeIds = this.getExistingNodeIds([...endpointIds]); + const rows: unknown[][] = []; + for (const edge of edges) { + if (!existingNodeIds.has(edge.source) || !existingNodeIds.has(edge.target)) continue; + rows.push([ + edge.source, + edge.target, + edge.kind, + edge.metadata ? JSON.stringify(edge.metadata) : null, + edge.line ?? null, + edge.column ?? null, + edge.provenance ?? null, + ]); + } + this.runBatched( + 'replaceEdgesBySynthesizer', + 'INSERT OR IGNORE INTO edges (source, target, kind, metadata, line, col, provenance) VALUES ', + '(?,?,?,?,?,?,?)', + rows + ); + })(); + } + /** * Get outgoing edges from a node */ @@ -2487,6 +2678,11 @@ export class QueryBuilder { ).run(key, value, Date.now()); } + /** Delete one project metadata key. */ + deleteMetadata(key: string): void { + this.db.prepare('DELETE FROM project_metadata WHERE key = ?').run(key); + } + /** * Get all metadata as a key-value record */ diff --git a/src/db/schema.sql b/src/db/schema.sql index 75df8c05c..761abef59 100644 --- a/src/db/schema.sql +++ b/src/db/schema.sql @@ -185,6 +185,14 @@ CREATE INDEX IF NOT EXISTS idx_unresolved_from_name ON unresolved_refs(from_node CREATE INDEX IF NOT EXISTS idx_unresolved_status ON unresolved_refs(status); CREATE INDEX IF NOT EXISTS idx_unresolved_failed_tail ON unresolved_refs(name_tail) WHERE status = 'failed'; CREATE INDEX IF NOT EXISTS idx_edges_provenance ON edges(provenance); +-- Whole-graph synthesizers replace their owned edge sets by the metadata key. +-- Keep that ownership lookup indexed; without this expression index every +-- incremental refresh scans the complete edge table. Migration v9 adds it to +-- existing databases. The guarded expression preserves the database's legacy +-- behavior of tolerating malformed metadata JSON at read boundaries. +CREATE INDEX IF NOT EXISTS idx_edges_synthesized_by + ON edges(json_extract(CASE WHEN json_valid(metadata) THEN metadata ELSE '{}' END, '$.synthesizedBy')) + WHERE json_extract(CASE WHEN json_valid(metadata) THEN metadata ELSE '{}' END, '$.synthesizedBy') IS NOT NULL; -- Project metadata for version/provenance tracking CREATE TABLE IF NOT EXISTS project_metadata ( diff --git a/src/extraction/extraction-version.ts b/src/extraction/extraction-version.ts index 07ccbb964..8ddab13b8 100644 --- a/src/extraction/extraction-version.ts +++ b/src/extraction/extraction-version.ts @@ -21,4 +21,4 @@ * turns the re-index hint into noise — keep it honest (see CLAUDE.md, "Honesty * in the product is load-bearing"). */ -export const EXTRACTION_VERSION = 25; +export const EXTRACTION_VERSION = 26; diff --git a/src/extraction/languages/postgres.ts b/src/extraction/languages/postgres.ts index e97c98e8e..912b1deef 100644 --- a/src/extraction/languages/postgres.ts +++ b/src/extraction/languages/postgres.ts @@ -1,5 +1,31 @@ import type { Node as SyntaxNode } from 'web-tree-sitter'; import type { Node, NodeKind } from '../../types'; +import { + POSTGRES_FOREIGN_KEY_DECORATOR, + encodePostgresForeignKeyDescriptor, + type PostgresForeignKeyDescriptor, +} from '../../postgres/foreign-key'; +import { + appendPostgresIdentifier, + parsePostgresQualifiedName, + serializePostgresQualifiedName, +} from '../../postgres/identifiers'; +import { + analyzePostgresSearchPath, + postgresSearchPathAtOffset, + type PostgresSearchPathState, +} from '../../postgres/search-path'; +import { + analyzePostgresTemporaryRelationVisibility, + postgresTemporaryRelationVisibleAt, + type PostgresTemporaryRelationVisibilityState, +} from '../../postgres/temporary-relations'; +import { + POSTGRES_TABLE_RELATION_DECORATOR, + encodePostgresTableRelationDescriptor, + type PostgresTableRelationDescriptor, + type PostgresTableRelationKind, +} from '../../postgres/table-relation'; import { getNodeText } from '../tree-sitter-helpers'; import type { ExtractorContext, LanguageExtractor } from '../tree-sitter-types'; @@ -30,6 +56,16 @@ const NAME_SEGMENT_TYPES = new Set(['ColId', 'ColLabel', 'type_function_name']); /** Per-extraction reference de-duplication. `ctx.nodes` is stable for a file. */ const emittedReferenceKeys = new WeakMap>(); +const extractionSearchPaths = new WeakMap(); +interface ExtractionTemporaryVisibilityCache { + scannedNodeCount: number; + candidates: Node[]; + state: PostgresTemporaryRelationVisibilityState; +} +const extractionTemporaryVisibility = new WeakMap< + readonly object[], + ExtractionTemporaryVisibilityCache +>(); function children(node: SyntaxNode): SyntaxNode[] { const result: SyntaxNode[] = []; @@ -69,6 +105,15 @@ function allDescendants(node: SyntaxNode, type: string): SyntaxNode[] { return result; } +function nearestAncestor(node: SyntaxNode, ...types: string[]): SyntaxNode | null { + let ancestor = node.parent; + while (ancestor) { + if (types.includes(ancestor.type)) return ancestor; + ancestor = ancestor.parent; + } + return null; +} + function hasDirectChild(node: SyntaxNode, type: string): boolean { return directChild(node, type) !== null; } @@ -107,35 +152,177 @@ function readSqlName(node: SyntaxNode | null, source: string): SqlName | null { visit(node); if (parts.length === 0) return null; + return sqlNameFromParts(parts); +} + +function sqlNameFromParts(parts: string[]): SqlName { return { parts, - qualified: parts.join('.'), + qualified: serializePostgresQualifiedName(parts), simple: parts[parts.length - 1]!, }; } -function nestedSchema(node: SyntaxNode, source: string): string | null { +interface NestedSchema { + found: boolean; + name: SqlName | null; +} + +function schemaName(node: SyntaxNode, source: string): SqlName | null { + return readSqlName(directChild(node, 'ColId', 'opt_single_name', 'RoleSpec'), source); +} + +function nestedSchema(node: SyntaxNode, source: string): NestedSchema { let parent = node.parent; while (parent) { if (parent.type === 'CreateSchemaStmt') { - const nameNode = directChild(parent, 'ColId', 'opt_single_name'); - return readSqlName(nameNode, source)?.qualified ?? null; + return { found: true, name: schemaName(parent, source) }; } parent = parent.parent; } - return null; + return { found: false, name: null }; +} + +function searchPathState(ctx: ExtractorContext): PostgresSearchPathState { + let state = extractionSearchPaths.get(ctx.nodes); + if (!state) { + state = analyzePostgresSearchPath(ctx.source); + extractionSearchPaths.set(ctx.nodes, state); + } + return state; +} + +/** + * Extraction appends to `ctx.nodes`. Scan each appended node once and rebuild + * the source timeline only when a new temporary declaration appears; relation + * lookups must not rescan a large SQL file for every statement. + */ +function temporaryVisibilityState(ctx: ExtractorContext): ExtractionTemporaryVisibilityCache { + let cached = extractionTemporaryVisibility.get(ctx.nodes); + if (!cached) { + cached = { + scannedNodeCount: 0, + candidates: [], + state: { changesByNodeId: new Map() }, + }; + extractionTemporaryVisibility.set(ctx.nodes, cached); + } + + let addedTemporary = false; + for (let index = cached.scannedNodeCount; index < ctx.nodes.length; index++) { + const candidate = ctx.nodes[index]!; + if (candidate.language === 'postgres' && + candidate.filePath === ctx.filePath && + candidate.decorators?.includes('postgres:temporary') === true) { + cached.candidates.push(candidate); + addedTemporary = true; + } + } + cached.scannedNodeCount = ctx.nodes.length; + if (addedTemporary) { + cached.state = analyzePostgresTemporaryRelationVisibility( + ctx.source, + cached.candidates, + searchPathState(ctx) + ); + } + return cached; +} + +function visibleTemporaryCandidates( + ctx: ExtractorContext, + name: SqlName, + offset: number +): Node[] { + const cached = temporaryVisibilityState(ctx); + if (cached.candidates.length === 0) return []; + const targetSchema = name.parts.length > 1 ? name.parts[0]! : null; + if (targetSchema !== null && targetSchema !== 'pg_temp' && + !/^pg_temp_[0-9]+$/.test(targetSchema)) return []; + + return cached.candidates.filter((candidate) => { + if (candidate.name !== name.simple) return false; + const parts = parsePostgresQualifiedName(candidate.qualifiedName); + if (!parts || parts.length < 2) return false; + if (targetSchema !== null && + name.parts.slice(1).some((part, index) => part !== parts[index + 1])) return false; + return postgresTemporaryRelationVisibleAt(cached.state, candidate.id, offset); + }); +} + +function nameInSearchPathSchema( + name: SqlName, + positionNode: SyntaxNode, + ctx: ExtractorContext +): SqlName { + if (name.parts.length > 1) return name; + const positions = searchPathState(ctx); + const path = postgresSearchPathAtOffset(positions, positionNode.startIndex); + const hasSameFileTemporary = visibleTemporaryCandidates( + ctx, + name, + positionNode.startIndex + ).length > 0; + if (hasSameFileTemporary) return sqlNameFromParts(['pg_temp', ...name.parts]); + if (path.schemas.length !== 1 || path.schemas[0] === '$user') return name; + const schema = path.schemas[0]!; + return sqlNameFromParts([schema, ...name.parts]); } -function objectName(node: SyntaxNode, nameNode: SyntaxNode | null, source: string): SqlName | null { - const name = readSqlName(nameNode, source); +function objectName( + node: SyntaxNode, + nameNode: SyntaxNode | null, + ctx: ExtractorContext +): SqlName | null { + const name = readSqlName(nameNode, ctx.source); if (!name || name.parts.length > 1 || node.type === 'CreateSchemaStmt') return name; - const schema = nestedSchema(node, source); - if (!schema) return name; - return { - parts: [schema, ...name.parts], - qualified: `${schema}.${name.qualified}`, - simple: name.simple, - }; + const nested = nestedSchema(node, ctx.source); + if (nested.found) { + // AUTHORIZATION CURRENT_USER has a runtime-only schema name. Keep nested + // declarations searchable but unqualified rather than falsely assigning + // them to the ambient/default search_path. + return nested.name + ? sqlNameFromParts([...nested.name.parts, ...name.parts]) + : name; + } + return nameInSearchPathSchema(name, node, ctx); +} + +function isTemporaryRelationName(name: SqlName | null): boolean { + const schema = name && name.parts.length > 1 ? name.parts[0]! : null; + return schema === 'pg_temp' || (schema !== null && /^pg_temp_[0-9]+$/.test(schema)); +} + +function hasTemporaryOption(node: SyntaxNode): boolean { + const options = directChild(node, 'OptTemp'); + return options !== null && ( + hasDirectChild(options, 'kw_temp') || hasDirectChild(options, 'kw_temporary') + ); +} + +/** + * PostgreSQL tables, views, and sequences share the temporary relation + * namespace. TEMP declarations with an unqualified name live in the + * session's pg_temp schema; explicitly targeting pg_temp has the same + * semantics even when the TEMP keyword is omitted. + */ +function relationDeclarationName( + node: SyntaxNode, + nameNode: SyntaxNode | null, + ctx: ExtractorContext +): { name: SqlName | null; temporary: boolean } { + const rawName = readSqlName(nameNode, ctx.source); + const temporary = hasTemporaryOption(node) || isTemporaryRelationName(rawName); + const name = temporary && rawName?.parts.length === 1 + ? sqlNameFromParts(['pg_temp', ...rawName.parts]) + : objectName(node, nameNode, ctx); + return { name, temporary }; +} + +function markTemporary(created: Node | null | undefined, temporary: boolean): void { + if (created && temporary && !created.decorators?.includes('postgres:temporary')) { + created.decorators = [...(created.decorators ?? []), 'postgres:temporary']; + } } function compactText(node: SyntaxNode, source: string, maxLength = 320): string { @@ -168,7 +355,22 @@ function addReference( keys = new Set(); emittedReferenceKeys.set(ctx.nodes, keys); } - const key = `${fromNodeId}\u0000${kind}\u0000${target.qualified}`; + // Search-path segment is semantic in SQL: the same unqualified name on + // opposite sides of SET search_path can resolve to different schemas, while + // ordinary repeated reads within one segment remain de-duplicated. + const activePath = postgresSearchPathAtOffset( + searchPathState(ctx), + positionNode.startIndex + ); + const temporaryBinding = visibleTemporaryCandidates( + ctx, + target, + positionNode.startIndex + ).map((candidate) => candidate.id).sort().join('\u001f'); + const key = `${fromNodeId}\u0000${kind}\u0000${target.qualified}` + + `\u0000${activePath.explicit ? 'explicit' : 'default'}` + + `\u0000${activePath.schemas.join('\u001f')}` + + `\u0000temp:${temporaryBinding}`; if (keys.has(key)) return; keys.add(key); @@ -190,7 +392,13 @@ function createDatabaseNode( qualifiedName = name.qualified, signature = compactText(node, ctx.source) ) { - return ctx.createNode(kind, name.simple, node, { + // Node IDs use the createNode `name` argument plus file/line. PostgreSQL can + // switch search_path and declare same-named objects more than once on a + // generated/minified line, so simple names are not a safe discriminator. + const idDiscriminator = `${qualifiedName}@${node.startPosition.row + 1}:` + + `${node.startPosition.column + 1}`; + return ctx.createNode(kind, idDiscriminator, node, { + name: name.simple, qualifiedName, signature, decorators: [`postgres:${objectKind}`], @@ -211,8 +419,14 @@ function createColumn( const name = readSqlName(nameNode, ctx.source); if (!name) return; const parentQualified = parentQualifiedOverride ?? currentScopeQualifiedName(ctx); - ctx.createNode('field', name.simple, node, { - qualifiedName: parentQualified ? `${parentQualified}.${name.simple}` : name.qualified, + const qualifiedName = parentQualified + ? appendPostgresIdentifier(parentQualified, name.simple) + : name.qualified; + const idDiscriminator = `${qualifiedName}@${node.startPosition.row + 1}:` + + `${node.startPosition.column + 1}`; + ctx.createNode('field', idDiscriminator, node, { + name: name.simple, + qualifiedName, signature: compactText(node, ctx.source, 200), decorators: ['postgres:column'], isExported: true, @@ -239,8 +453,14 @@ function createEnumMembers(node: SyntaxNode, ctx: ExtractorContext): void { ? raw.slice(1, -1).replace(/''/g, "'") : raw; if (!value) continue; - ctx.createNode('enum_member', value, literal, { - qualifiedName: parentQualified ? `${parentQualified}.${value}` : value, + const qualifiedName = parentQualified + ? appendPostgresIdentifier(parentQualified, value) + : serializePostgresQualifiedName([value]); + const idDiscriminator = `${qualifiedName}@${literal.startPosition.row + 1}:` + + `${literal.startPosition.column + 1}`; + ctx.createNode('enum_member', idDiscriminator, literal, { + name: value, + qualifiedName, signature: raw, decorators: ['postgres:enum-value'], isExported: true, @@ -262,6 +482,80 @@ function withCreatedScope( } } +function createTableRelationFact( + ctx: ExtractorContext, + clause: SyntaxNode, + sourceTable: SqlName, + targetTable: SqlName, + relation: PostgresTableRelationKind, + sourcePosition: SyntaxNode, + targetPosition: SyntaxNode, + extra: Pick = {} +): void { + const descriptor: PostgresTableRelationDescriptor = { + relation, + sourceTable: sourceTable.qualified, + targetTable: targetTable.qualified, + ...extra, + }; + const label = `${relation.toUpperCase()} → ${targetTable.qualified}`; + const identity = `${label} @${clause.startPosition.row + 1}:` + + `${clause.startPosition.column + 1}`; + const created = ctx.createNode('constant', `${sourceTable.qualified}.${identity}`, clause, { + name: label, + qualifiedName: appendPostgresIdentifier(sourceTable.qualified, identity), + signature: compactText(clause, ctx.source), + decorators: [ + POSTGRES_TABLE_RELATION_DECORATOR, + encodePostgresTableRelationDescriptor(descriptor), + ], + isExported: true, + }); + withCreatedScope(ctx, created, () => { + if (!created) return; + addReference(ctx, created.id, sourceTable, 'references', sourcePosition); + addReference(ctx, created.id, targetTable, 'references', targetPosition); + }); +} + +function createTableDeclarationRelations( + node: SyntaxNode, + ctx: ExtractorContext, + sourceTable: SqlName, + sourcePosition: SyntaxNode +): void { + const directNames = children(node).filter((child) => child.type === 'qualified_name'); + if (hasDirectChild(node, 'kw_partition') && hasDirectChild(node, 'kw_of')) { + const targetNode = directNames.find((candidate) => candidate.startIndex > sourcePosition.endIndex); + const target = readSqlName(targetNode ?? null, ctx.source); + if (targetNode && target) { + createTableRelationFact( + ctx, node, sourceTable, target, 'partition-of', sourcePosition, targetNode + ); + } + } + + const inheritance = directChild(node, 'OptInherit'); + if (inheritance) { + for (const targetNode of allDescendants(inheritance, 'qualified_name')) { + const target = readSqlName(targetNode, ctx.source); + if (target) { + createTableRelationFact( + ctx, targetNode, sourceTable, target, 'inherits', sourcePosition, targetNode + ); + } + } + } + + for (const like of allDescendants(node, 'TableLikeClause')) { + const targetNode = directChild(like, 'qualified_name'); + const target = readSqlName(targetNode, ctx.source); + if (targetNode && target) { + createTableRelationFact(ctx, like, sourceTable, target, 'like', sourcePosition, targetNode); + } + } +} + function createTableLike( node: SyntaxNode, ctx: ExtractorContext, @@ -269,10 +563,12 @@ function createTableLike( objectKind: string, explicitColumnsContainer?: SyntaxNode | null ): boolean { - const name = objectName(node, nameNode, ctx.source); + const { name, temporary } = relationDeclarationName(node, nameNode, ctx); if (!name) return true; const created = createDatabaseNode(ctx, node, name, 'struct', objectKind); + markTemporary(created, temporary); withCreatedScope(ctx, created, () => { + if (nameNode) createTableDeclarationRelations(node, ctx, name, nameNode); createExplicitColumns(explicitColumnsContainer ?? node, ctx); walkChildren(node, ctx); }); @@ -290,7 +586,7 @@ function routineSignature(node: SyntaxNode, name: SqlName, source: string): stri } function createRoutine(node: SyntaxNode, ctx: ExtractorContext): boolean { - const name = objectName(node, directChild(node, 'func_name'), ctx.source); + const name = objectName(node, directChild(node, 'func_name'), ctx); if (!name) return true; const objectKind = hasDirectChild(node, 'kw_procedure') ? 'procedure' : 'function'; const created = createDatabaseNode( @@ -308,7 +604,7 @@ function createRoutine(node: SyntaxNode, ctx: ExtractorContext): boolean { function createType(node: SyntaxNode, ctx: ExtractorContext): boolean { if (!hasDirectChild(node, 'kw_type')) return false; - const name = objectName(node, directChild(node, 'any_name'), ctx.source); + const name = objectName(node, directChild(node, 'any_name'), ctx); if (!name) return true; const isEnum = hasDirectChild(node, 'kw_enum'); const created = createDatabaseNode( @@ -326,7 +622,7 @@ function createType(node: SyntaxNode, ctx: ExtractorContext): boolean { } function createDomain(node: SyntaxNode, ctx: ExtractorContext): boolean { - const name = objectName(node, directChild(node, 'any_name'), ctx.source); + const name = objectName(node, directChild(node, 'any_name'), ctx); if (!name) return true; const created = createDatabaseNode(ctx, node, name, 'type_alias', 'domain'); withCreatedScope(ctx, created, () => walkChildren(node, ctx)); @@ -334,8 +630,11 @@ function createDomain(node: SyntaxNode, ctx: ExtractorContext): boolean { } function createSchema(node: SyntaxNode, ctx: ExtractorContext): boolean { - const name = objectName(node, directChild(node, 'ColId', 'opt_single_name'), ctx.source); - if (!name) return true; + const name = schemaName(node, ctx.source); + if (!name) { + walkChildren(node, ctx); + return true; + } const created = createDatabaseNode(ctx, node, name, 'namespace', 'schema'); withCreatedScope(ctx, created, () => walkChildren(node, ctx)); return true; @@ -347,8 +646,9 @@ function createTrigger(node: SyntaxNode, ctx: ExtractorContext): boolean { const tableName = readSqlName(tableNode, ctx.source); if (!triggerName) return true; - const qualifiedName = tableName - ? `${tableName.qualified}.${triggerName.simple}` + const displayTableName = tableName ? nameInSearchPathSchema(tableName, node, ctx) : null; + const qualifiedName = displayTableName + ? appendPostgresIdentifier(displayTableName.qualified, triggerName.simple) : triggerName.qualified; const created = createDatabaseNode( ctx, @@ -362,6 +662,26 @@ function createTrigger(node: SyntaxNode, ctx: ExtractorContext): boolean { if (created && tableNode && tableName) { addReference(ctx, created.id, tableName, 'references', tableNode); } + const constraintSource = directChild(node, 'OptConstrFromTable'); + const sourceTableNode = constraintSource + ? directChild(constraintSource, 'qualified_name') + : null; + const sourceTable = readSqlName(sourceTableNode, ctx.source); + if (created && sourceTableNode && sourceTable) { + addReference(ctx, created.id, sourceTable, 'references', sourceTableNode); + } + if (tableNode && displayTableName && sourceTableNode && sourceTable) { + createTableRelationFact( + ctx, + constraintSource ?? node, + displayTableName, + sourceTable, + 'constraint-trigger', + tableNode, + sourceTableNode, + { triggerName: triggerName.simple } + ); + } const routineNode = directChild(node, 'func_name'); const routineName = readSqlName(routineNode, ctx.source); if (created && routineNode && routineName) { @@ -377,8 +697,9 @@ function createPolicy(node: SyntaxNode, ctx: ExtractorContext): boolean { const tableNode = directChild(node, 'qualified_name'); const tableName = readSqlName(tableNode, ctx.source); if (!policyName) return true; - const qualifiedName = tableName - ? `${tableName.qualified}.${policyName.simple}` + const displayTableName = tableName ? nameInSearchPathSchema(tableName, node, ctx) : null; + const qualifiedName = displayTableName + ? appendPostgresIdentifier(displayTableName.qualified, policyName.simple) : policyName.qualified; const created = createDatabaseNode( ctx, @@ -406,10 +727,13 @@ function createIndex(node: SyntaxNode, ctx: ExtractorContext): boolean { walkChildren(node, ctx); return true; } - const schema = tableName && tableName.parts.length > 1 - ? tableName.parts.slice(0, -1).join('.') + const displayTableName = tableName ? nameInSearchPathSchema(tableName, node, ctx) : null; + const schema = displayTableName && displayTableName.parts.length > 1 + ? serializePostgresQualifiedName(displayTableName.parts.slice(0, -1)) : null; - const qualifiedName = schema ? `${schema}.${rawName.simple}` : rawName.qualified; + const qualifiedName = schema + ? appendPostgresIdentifier(schema, rawName.simple) + : rawName.qualified; const created = createDatabaseNode( ctx, node, @@ -423,9 +747,14 @@ function createIndex(node: SyntaxNode, ctx: ExtractorContext): boolean { } function createSequence(node: SyntaxNode, ctx: ExtractorContext): boolean { - const name = objectName(node, directChild(node, 'qualified_name'), ctx.source); + const { name, temporary } = relationDeclarationName( + node, + directChild(node, 'qualified_name'), + ctx + ); if (!name) return true; const created = createDatabaseNode(ctx, node, name, 'variable', 'sequence'); + markTemporary(created, temporary); withCreatedScope(ctx, created, () => walkChildren(node, ctx)); return true; } @@ -438,6 +767,147 @@ function createExtension(node: SyntaxNode, ctx: ExtractorContext): boolean { return true; } +function columnNames(container: SyntaxNode | null, source: string): string[] { + if (!container) return []; + const result: string[] = []; + for (const column of allDescendants(container, 'columnElem')) { + const name = readSqlName(column, source); + if (name) result.push(name.simple); + } + return result; +} + +function foreignKeyAction( + text: string, + event: 'DELETE' | 'UPDATE' +): PostgresForeignKeyDescriptor['onDelete'] { + const match = new RegExp( + `\\bON\\s+${event}\\s+(NO\\s+ACTION|RESTRICT|CASCADE|SET\\s+NULL|SET\\s+DEFAULT)\\b`, + 'i' + ).exec(text); + return match?.[1] + ? match[1].replace(/\s+/g, ' ').toLowerCase() as PostgresForeignKeyDescriptor['onDelete'] + : undefined; +} + +/** + * Create a durable constraint fact instead of attributing REFERENCES to the + * migration file. The constraint points at both endpoint relations; a + * post-resolution pass turns those two exact facts into a direct table edge. + */ +function createForeignKey(node: SyntaxNode, ctx: ExtractorContext): boolean { + const marker = directChild(node, 'kw_references'); + if (!marker || (node.type === 'ConstraintElem' && !hasDirectChild(node, 'kw_foreign'))) { + walkChildren(node, ctx); + return true; + } + + const targetNode = children(node).find( + (child) => child.type === 'qualified_name' && child.startIndex > marker.endIndex + ) ?? null; + const target = readSqlName(targetNode, ctx.source); + if (!targetNode || !target) { + walkChildren(node, ctx); + return true; + } + + const alter = nearestAncestor(node, 'AlterTableStmt'); + const alterRelation = alter ? directChild(alter, 'relation_expr') : null; + const alterTableNode = alterRelation ? firstDescendant(alterRelation, 'qualified_name') : null; + const rawAlterTable = readSqlName(alterTableNode, ctx.source); + const alterTable = rawAlterTable && alter + ? nameInSearchPathSchema(rawAlterTable, alter, ctx) + : rawAlterTable; + const scope = currentScopeNode(ctx); + const scopeIsTable = scope?.language === 'postgres' && scope.kind === 'struct' && + (scope.decorators?.includes('postgres:table') === true || + scope.decorators?.includes('postgres:foreign-table') === true); + const sourceTable: SqlName | null = alterTable ?? (scopeIsTable && scope ? { + parts: parsePostgresQualifiedName(scope.qualifiedName) ?? [scope.qualifiedName], + qualified: scope.qualifiedName, + simple: scope.name, + } : null); + if (!sourceTable) { + walkChildren(node, ctx); + return true; + } + + const wrapper = nearestAncestor(node, 'TableConstraint', 'ColConstraint'); + const constraintName = readSqlName(wrapper ? directChild(wrapper, 'name') : null, ctx.source); + let sourceColumns: string[]; + if (node.type === 'ConstraintElem') { + sourceColumns = columnNames(directChild(node, 'columnList'), ctx.source); + } else { + const column = nearestAncestor(node, 'columnDef'); + const columnName = readSqlName(column ? directChild(column, 'ColId') : null, ctx.source); + sourceColumns = columnName ? [columnName.simple] : []; + } + + const targetColumnsContainer = children(node).find( + (child) => child.startIndex >= targetNode.endIndex && + (child.type === 'opt_column_and_period_list' || child.type === 'opt_column_list') + ) ?? null; + const targetColumns = columnNames(targetColumnsContainer, ctx.source); + const raw = getNodeText(nearestAncestor(node, 'alter_table_cmd') ?? wrapper ?? node, ctx.source); + const compact = raw.replace(/\s+/g, ' ').trim(); + const matchType = /\bMATCH\s+(FULL|PARTIAL|SIMPLE)\b/i.exec(compact)?.[1]?.toLowerCase() as + PostgresForeignKeyDescriptor['match']; + const initially = /\bINITIALLY\s+(DEFERRED|IMMEDIATE)\b/i.exec(compact)?.[1]?.toLowerCase() as + PostgresForeignKeyDescriptor['initially']; + const onDelete = foreignKeyAction(compact, 'DELETE'); + const onUpdate = foreignKeyAction(compact, 'UPDATE'); + const descriptor: PostgresForeignKeyDescriptor = { + sourceTable: sourceTable.qualified, + targetTable: target.qualified, + ...(constraintName ? { constraintName: constraintName.simple } : {}), + sourceColumns, + targetColumns, + ...(matchType ? { match: matchType } : {}), + ...(onDelete ? { onDelete } : {}), + ...(onUpdate ? { onUpdate } : {}), + ...(/\bNOT\s+DEFERRABLE\b/i.test(compact) + ? { deferrable: false } + : /\bDEFERRABLE\b/i.test(compact) + ? { deferrable: true } + : {}), + ...(initially ? { initially } : {}), + ...(/\bNOT\s+VALID\b/i.test(compact) ? { notValid: true } : {}), + }; + + const sourceLabel = sourceColumns.length > 0 ? sourceColumns.join(', ') : '?'; + const simple = constraintName?.simple ?? `FOREIGN KEY (${sourceLabel})`; + const qualifiedIdentity = constraintName?.simple ?? + `FOREIGN KEY (${sourceLabel}) -> ${target.qualified} ` + + `@${node.startPosition.row + 1}:${node.startPosition.column + 1}`; + const name: SqlName = { + parts: [...sourceTable.parts, qualifiedIdentity], + qualified: appendPostgresIdentifier(sourceTable.qualified, qualifiedIdentity), + simple, + }; + const idDiscriminator = `${sourceTable.qualified}.${qualifiedIdentity} ` + + `@${node.startPosition.row + 1}:${node.startPosition.column + 1}`; + // createNode's stable ID is based on its `name` argument and start line. Use + // the disambiguated identity there, then retain the human-facing name in the + // stored node. Generated/minified DDL can declare two anonymous constraints + // on one line; using `simple` for the ID would silently collapse one of them. + const created = ctx.createNode('constant', idDiscriminator, wrapper ?? node, { + name: simple, + qualifiedName: name.qualified, + signature: compactText(wrapper ?? node, ctx.source), + decorators: [ + POSTGRES_FOREIGN_KEY_DECORATOR, + encodePostgresForeignKeyDescriptor(descriptor), + ], + isExported: true, + }); + withCreatedScope(ctx, created, () => { + if (!created) return; + addReference(ctx, created.id, sourceTable, 'references', alterTableNode ?? node); + addReference(ctx, created.id, target, 'references', targetNode); + }); + return true; +} + /** * Model ALTER TABLE ADD COLUMN as a migration delta rather than attaching the * new field to an arbitrary historical CREATE TABLE node. The delta references @@ -445,16 +915,72 @@ function createExtension(node: SyntaxNode, ctx: ExtractorContext): boolean { * a future ordered-migration layer can fold these deltas into an effective * schema without changing the extracted facts. */ +function createAlterTableRelations( + node: SyntaxNode, + ctx: ExtractorContext, + tableName: SqlName, + tableNode: SyntaxNode +): void { + const partition = directChild(node, 'partition_cmd'); + if (partition) { + const childNode = directChild(partition, 'qualified_name'); + const rawChild = readSqlName(childNode, ctx.source); + const child = rawChild ? nameInSearchPathSchema(rawChild, partition, ctx) : null; + const attach = hasDirectChild(partition, 'kw_attach'); + const detach = hasDirectChild(partition, 'kw_detach'); + if (childNode && child && (attach || detach)) { + const compact = compactText(partition, ctx.source).toLowerCase(); + const mode = /\bconcurrently\b/.test(compact) + ? 'concurrently' as const + : /\bfinalize\b/.test(compact) + ? 'finalize' as const + : undefined; + createTableRelationFact( + ctx, + partition, + child, + tableName, + attach ? 'attach-partition' : 'detach-partition', + childNode, + tableNode, + mode ? { mode } : {} + ); + } + } + + const commands = directChild(node, 'alter_table_cmds'); + if (!commands) return; + for (const command of allDescendants(commands, 'alter_table_cmd')) { + if (!hasDirectChild(command, 'kw_inherit')) continue; + const parentNode = directChild(command, 'qualified_name'); + const parent = readSqlName(parentNode, ctx.source); + if (parentNode && parent) { + createTableRelationFact( + ctx, + command, + tableName, + parent, + hasDirectChild(command, 'kw_no') ? 'no-inherit' : 'inherit', + tableNode, + parentNode + ); + } + } +} + function createAlterTableDeltas(node: SyntaxNode, ctx: ExtractorContext): boolean { const relation = directChild(node, 'relation_expr'); const tableNode = relation ? firstDescendant(relation, 'qualified_name') : null; - const tableName = readSqlName(tableNode, ctx.source); + const rawTableName = readSqlName(tableNode, ctx.source); + const tableName = rawTableName ? nameInSearchPathSchema(rawTableName, node, ctx) : null; const ownerId = currentScopeId(ctx); if (!tableNode || !tableName || !ownerId) { walkChildren(node, ctx); return true; } + createAlterTableRelations(node, ctx, tableName, tableNode); + // Retain the statement-level dependency that ALTER TABLE emitted before // column deltas were modeled. addReference(ctx, ownerId, tableName, 'references', tableNode); @@ -473,7 +999,7 @@ function createAlterTableDeltas(node: SyntaxNode, ctx: ExtractorContext): boolea const deltaSimple = `ADD COLUMN ${columnName.simple}`; const deltaName: SqlName = { parts: [...tableName.parts, deltaSimple], - qualified: `${tableName.qualified}.${deltaSimple}`, + qualified: appendPostgresIdentifier(tableName.qualified, deltaSimple), simple: deltaSimple, }; const created = createDatabaseNode( @@ -569,20 +1095,6 @@ function emitRelationReference(node: SyntaxNode, ctx: ExtractorContext): boolean return true; } -function emitForeignKeyReference(node: SyntaxNode, ctx: ExtractorContext): boolean { - const fromNodeId = currentScopeId(ctx); - const marker = directChild(node, 'kw_references'); - if (fromNodeId && marker) { - const targetNode = children(node).find( - (child) => child.type === 'qualified_name' && child.startIndex > marker.endIndex - ) ?? null; - const target = readSqlName(targetNode, ctx.source); - if (targetNode && target) addReference(ctx, fromNodeId, target, 'references', targetNode); - } - walkChildren(node, ctx); - return true; -} - function emitRoutineCall(node: SyntaxNode, ctx: ExtractorContext): boolean { const nameNode = directChild(node, 'func_name'); const name = readSqlName(nameNode, ctx.source); @@ -689,7 +1201,8 @@ export const postgresExtractor: LanguageExtractor = { const nameNode = directChild(node, 'ColId'); const scope = currentScopeNode(ctx); const isTableColumn = scope?.decorators?.some( - (decorator) => decorator === 'postgres:table' || decorator === 'postgres:foreign-table' + (decorator) => decorator === 'postgres:table' || + decorator === 'postgres:foreign-table' ) ?? false; if (nameNode && isTableColumn) createColumn(ctx, node, nameNode); walkChildren(node, ctx); @@ -698,7 +1211,7 @@ export const postgresExtractor: LanguageExtractor = { case 'ConstraintElem': case 'ColConstraintElem': - return emitForeignKeyReference(node, ctx); + return createForeignKey(node, ctx); case 'relation_expr': case 'insert_target': diff --git a/src/index.ts b/src/index.ts index 461ff4797..3d5bb406a 100644 --- a/src/index.ts +++ b/src/index.ts @@ -932,6 +932,17 @@ export class CodeGraph { await this.resolver.resolveDeferredThisMemberRefs(); } + // Whole-graph FK edges can have both endpoints in unchanged CREATE + // migrations while their owning ALTER migration is the only file that + // changed. Scoped sync resolution therefore refreshes this owned edge + // set explicitly; node-cascade deletion alone cannot remove it. + // Scoped resolution does not run the whole-graph exact FK projection; + // batched resolution does, but this call is still cheap there because + // the persisted state fingerprint makes it a no-write fast path. Run + // it even on a no-change sync so a process killed after the store phase + // is healed deterministically on the next sync. + await this.resolver.refreshPostgresForeignKeys(); + // Refresh planner stats + checkpoint the WAL after bulk writes. // Off-thread — see indexAll's call site. if (filesChanged || result.filesRemoved > 0 || orphanCount > 0) { @@ -1149,7 +1160,12 @@ export class CodeGraph { resolveReferences(onProgress?: (current: number, total: number) => void): ResolutionResult { // Get all unresolved references from the database const unresolvedRefs = this.queries.getUnresolvedReferences(); - return this.resolver.resolveAndPersist(unresolvedRefs, onProgress); + const result = this.resolver.resolveAndPersist(unresolvedRefs, onProgress); + // Keep the synchronous API's result immediately traversable, just like the + // batched/full-index path. PostgreSQL FK table edges depend on both resolved + // endpoint refs and therefore cannot be emitted during extraction. + this.resolver.refreshPostgresForeignKeysSync(); + return result; } /** @@ -1276,6 +1292,11 @@ export class CodeGraph { return this.queries.getNodesByName(name); } + /** Exact qualified-name lookup using the dedicated database index. */ + getNodesByQualifiedName(qualifiedName: string): Node[] { + return this.queries.getNodesByQualifiedNameExact(qualifiedName); + } + /** Nodes whose name starts with `prefix` (index range scan, capped). */ getNodesByNamePrefix(prefix: string, limit = 20): Node[] { return this.queries.getNodesByNamePrefix(prefix, limit); diff --git a/src/mcp/tools.ts b/src/mcp/tools.ts index b31c64fc7..f623617cf 100644 --- a/src/mcp/tools.ts +++ b/src/mcp/tools.ts @@ -21,7 +21,16 @@ import { type WorktreeIndexMismatch, } from '../sync/worktree'; import type { PendingFile } from '../sync'; -import type { Node, Edge, SearchResult, Subgraph, NodeKind } from '../types'; +import { + LANGUAGES, + NODE_KINDS, + type Node, + type Edge, + type SearchResult, + type Subgraph, + type NodeKind, + type Language, +} from '../types'; import { isTestFile, normalizeNameToken } from '../search/query-utils'; import { existsSync, @@ -31,6 +40,10 @@ import { clamp, validatePathWithinRoot, validateProjectPath, isConfigLeafNode, C import { isGeneratedFile } from '../extraction/generated-detection'; import { scanDynamicDispatch } from './dynamic-boundaries'; import { getUpdateNotice } from '../upgrade/update-check'; +import { + parsePostgresQualifiedName, + serializePostgresQualifiedName, +} from '../postgres/identifiers'; /** * An expected, recoverable "codegraph can't serve this" condition — most @@ -80,6 +93,31 @@ const MAX_PATH_LENGTH = 4_096; */ const RUST_PATH_PREFIXES = new Set(['crate', 'super', 'self']); +/** + * Canonicalize a schema-qualified PostgreSQL lookup using PostgreSQL's + * identifier rules: unquoted segments fold to lower case while quoted + * segments keep their spelling and may contain dots. + */ +function canonicalPostgresLookup(symbol: string): string | null { + const parts = parsePostgresQualifiedName(symbol); + return parts && parts.length > 1 ? serializePostgresQualifiedName(parts) : null; +} + +/** + * Prefer the literal qualified-name index hit used by every language. When it + * misses, also probe PostgreSQL's canonical spelling, but only accept a + * PostgreSQL node so a dotted TypeScript/Python query cannot be redirected to + * an unrelated case-folded symbol. + */ +function getDirectQualifiedSymbolMatches(cg: CodeGraph, symbol: string): Node[] { + const direct = cg.getNodesByQualifiedName(symbol); + if (direct.length > 0) return direct; + + const postgresName = canonicalPostgresLookup(symbol); + if (!postgresName || postgresName === symbol) return []; + return cg.getNodesByQualifiedName(postgresName).filter((node) => node.language === 'postgres'); +} + /** * Node kinds that contain other symbols. For these, `codegraph_node` with * `includeCode=true` returns a structural outline (member names + signatures @@ -547,7 +585,12 @@ export const tools: ToolDefinition[] = [ kind: { type: 'string', description: 'Filter by node kind', - enum: ['function', 'method', 'class', 'interface', 'type', 'variable', 'route', 'component'], + enum: [...NODE_KINDS, 'type'], + }, + language: { + type: 'string', + description: 'Filter by source language (for example postgres or typescript)', + enum: [...LANGUAGES], }, limit: { type: 'number', @@ -1502,10 +1545,15 @@ export class ToolHandler { const kind = rawKind === 'type' ? 'type_alias' : rawKind; const rawLimit = Number(args.limit) || 10; const limit = clamp(rawLimit, 1, 100); + const rawLanguage = typeof args.language === 'string' ? args.language : undefined; + const language = rawLanguage && LANGUAGES.includes(rawLanguage as Language) + ? rawLanguage as Language + : undefined; const results = cg.searchNodes(query, { limit, kinds: kind ? [kind as NodeKind] : undefined, + languages: language ? [language] : undefined, }); if (results.length === 0) { @@ -4028,11 +4076,16 @@ export class ToolHandler { return synth ? `${base} [${synth.compact}]` : base; }; const collect = (edges: Array<{ node: Node; edge: Edge }>): Array<{ node: Node; edge: Edge }> => { - const seen = new Set([node.id]); + const seen = new Set(); const out: Array<{ node: Node; edge: Edge }> = []; for (const e of edges) { - if (seen.has(e.node.id)) continue; - seen.add(e.node.id); + if (e.node.id === node.id) continue; + const relation = typeof e.edge.metadata?.postgresRelation === 'string' + ? e.edge.metadata.postgresRelation + : e.edge.kind; + const key = `${e.node.id}\u0000${relation}`; + if (seen.has(key)) continue; + seen.add(key); out.push(e); } return out; @@ -4041,12 +4094,85 @@ export class ToolHandler { const callers = collect(cg.getCallers(node.id)); if (callees.length === 0 && callers.length === 0) return ''; const lines: string[] = ['', '**Trail — codegraph_node any of these to follow it (no Read needed)**']; - if (callees.length > 0) { - lines.push(`**Calls →** ${callees.slice(0, TRAIL_CAP).map(fmt).join(', ')}${callees.length > TRAIL_CAP ? `, +${callees.length - TRAIL_CAP} more` : ''}`); - } - if (callers.length > 0) { - lines.push(`**Called by ←** ${callers.slice(0, TRAIL_CAP).map(fmt).join(', ')}${callers.length > TRAIL_CAP ? `, +${callers.length - TRAIL_CAP} more` : ''}`); - } + const push = ( + label: string, + entries: Array<{ node: Node; edge: Edge }>, + formatter = fmt + ): void => { + if (entries.length === 0) return; + lines.push( + `**${label}** ${entries.slice(0, TRAIL_CAP).map(formatter).join(', ')}` + + (entries.length > TRAIL_CAP ? `, +${entries.length - TRAIL_CAP} more` : '') + ); + }; + const isCallLike = ({ edge }: { edge: Edge }) => + edge.kind === 'calls' || edge.kind === 'instantiates'; + + // Database relations need domain labels, not the generic call vocabulary: + // a table is referenced by a trigger/FK/view; none of those "call" it. + if (node.language === 'postgres' && node.kind === 'struct') { + const isForeignKeyEdge = ({ edge }: { edge: Edge }) => + edge.metadata?.postgresRelation === 'foreign-key'; + const isTableRelationEdge = ({ edge }: { edge: Edge }) => { + const relation = edge.metadata?.postgresRelation; + return typeof relation === 'string' && + relation !== 'foreign-key' && relation !== 'schema-containment'; + }; + const isTrigger = ({ node: related }: { node: Node }) => + related.decorators?.includes('postgres:trigger') === true; + const isConstraint = ({ node: related }: { node: Node }) => + related.decorators?.includes('postgres:foreign-key') === true; + const fkLabel = ({ node: related, edge }: { node: Node; edge: Edge }) => { + const raw = edge.metadata?.constraints; + const constraints = Array.isArray(raw) ? raw as Array> : []; + const names = constraints + .map((constraint) => constraint.constraintName) + .filter((name): name is string => typeof name === 'string'); + const qualified = related.qualifiedName || related.name; + const suffix = names.length > 0 ? ` [${names.join(', ')}]` : ''; + return `${qualified} (${related.filePath}:${related.startLine})${suffix}`; + }; + const triggerLabel = ({ node: trigger }: { node: Node; edge: Edge }) => { + const routine = cg.getCallees(trigger.id).find(({ edge }) => edge.kind === 'calls')?.node; + const hop = routine ? ` → ${routine.qualifiedName || routine.name}` : ''; + return `${trigger.name}${hop} (${trigger.filePath}:${trigger.startLine})`; + }; + const relationLabel = ({ node: related, edge }: { node: Node; edge: Edge }) => + `${related.qualifiedName || related.name} [${String(edge.metadata?.postgresRelation)}] ` + + `(${related.filePath}:${related.startLine})`; + + const fkOutgoing = callees.filter(isForeignKeyEdge); + const fkIncoming = callers.filter(isForeignKeyEdge); + const relationsOutgoing = callees.filter(isTableRelationEdge); + const relationsIncoming = callers.filter(isTableRelationEdge); + const triggers = callers.filter(isTrigger); + const constraints = callers.filter(isConstraint); + const usedOutgoing = new Set([ + ...fkOutgoing.map(({ node: related }) => related.id), + ...relationsOutgoing.map(({ node: related }) => related.id), + ]); + const usedIncoming = new Set([ + ...fkIncoming.map(({ node: related }) => related.id), + ...relationsIncoming.map(({ node: related }) => related.id), + ...triggers.map(({ node: related }) => related.id), + ...constraints.map(({ node: related }) => related.id), + ]); + + push('Foreign keys →', fkOutgoing, fkLabel); + push('Referenced by foreign keys ←', fkIncoming, fkLabel); + push('Table relations →', relationsOutgoing, relationLabel); + push('Related tables ←', relationsIncoming, relationLabel); + push('Triggers ←', triggers, triggerLabel); + push('Foreign-key constraints ←', constraints); + push('References →', callees.filter((entry) => !usedOutgoing.has(entry.node.id))); + push('Referenced by ←', callers.filter((entry) => !usedIncoming.has(entry.node.id))); + return lines.join('\n'); + } + + push('Calls →', callees.filter(isCallLike)); + push('References →', callees.filter((entry) => !isCallLike(entry))); + push('Called by ←', callers.filter(isCallLike)); + push('Referenced by ←', callers.filter((entry) => !isCallLike(entry))); return lines.join('\n'); } @@ -4404,6 +4530,13 @@ export class ToolHandler { if (node.name === symbol) return true; // File basename match (e.g., "product-card" matches "product-card.liquid") if (node.kind === 'file' && node.name.replace(/\.[^.]+$/, '') === symbol) return true; + // PostgreSQL intentionally preserves SQL's dotted qualified names instead + // of CodeGraph's usual `::` hierarchy separator. + if (node.qualifiedName === symbol) return true; + if (node.language === 'postgres') { + const postgresName = canonicalPostgresLookup(symbol); + if (postgresName) return node.qualifiedName === postgresName; + } // Qualified-name lookups: split on any supported separator. `\w` keeps // identifier chars (incl. `_`) intact; everything else is treated as @@ -4463,6 +4596,17 @@ export class ToolHandler { return fuzzy[0] ? [fuzzy[0].node] : []; } + + // Literal qualified names (notably PostgreSQL schema.object) have a + // dedicated index. Probe it before FTS so a large set of nested symbols + // cannot cap out the exact object. + const direct = getDirectQualifiedSymbolMatches(cg, symbol); + if (direct.length > 0) { + return [...direct].sort((a, b) => + (isGeneratedFile(a.filePath) ? 1 : 0) - (isGeneratedFile(b.filePath) ? 1 : 0) + ); + } + // Qualified lookup (`Session.request`, `stage_apply::run`): FTS + matchesSymbol. const limit = 50; let results = cg.searchNodes(symbol, { limit }); @@ -4516,6 +4660,15 @@ export class ToolHandler { return { nodes, note: '' }; } } + if (/[.\/]|::/.test(symbol)) { + const direct = getDirectQualifiedSymbolMatches(cg, symbol); + if (direct.length > 0) { + const nodes = [...direct].sort((a, b) => + (isGeneratedFile(a.filePath) ? 1 : 0) - (isGeneratedFile(b.filePath) ? 1 : 0) + ); + return { nodes, note: '' }; + } + } let results = cg.searchNodes(symbol, { limit: 50 }); // Mirror the fallback in `findSymbol` for qualified queries — FTS @@ -4574,8 +4727,16 @@ export class ToolHandler { for (const result of results) { const { node } = result; const location = node.startLine ? `:${node.startLine}` : ''; + const postgresKind = node.language === 'postgres' + ? node.decorators?.find((decorator) => + decorator.startsWith('postgres:') && + !decorator.startsWith('postgres:foreign-key-data:') && + !decorator.startsWith('postgres:table-relation-data:') + )?.slice('postgres:'.length) + : undefined; + const displayName = node.language === 'postgres' ? node.qualifiedName : node.name; // Compact format: one line per result with key info - lines.push(`**${node.name}** (${node.kind})`); + lines.push(`**${displayName}** (${postgresKind ?? node.kind})`); lines.push(`${node.filePath}${location}`); if (node.signature) lines.push(`\`${node.signature}\``); lines.push(''); @@ -4667,8 +4828,16 @@ export class ToolHandler { private formatNodeDetails(node: Node, code: string | null, outline?: string | null): string { const location = node.startLine ? `:${node.startLine}` : ''; + const postgresKind = node.language === 'postgres' + ? node.decorators?.find((decorator) => + decorator.startsWith('postgres:') && + !decorator.startsWith('postgres:foreign-key-data:') && + !decorator.startsWith('postgres:table-relation-data:') + )?.slice('postgres:'.length) + : undefined; + const displayName = node.language === 'postgres' ? node.qualifiedName : node.name; const lines: string[] = [ - `**${node.name}** (${node.kind})`, + `**${displayName}** (${postgresKind ?? node.kind})`, '', `**Location:** ${node.filePath}${location}`, ]; diff --git a/src/postgres/foreign-key.ts b/src/postgres/foreign-key.ts new file mode 100644 index 000000000..6340f18e4 --- /dev/null +++ b/src/postgres/foreign-key.ts @@ -0,0 +1,49 @@ +/** Shared encoding for PostgreSQL foreign-key facts extracted from SQL. */ + +export const POSTGRES_FOREIGN_KEY_DECORATOR = 'postgres:foreign-key'; +export const POSTGRES_FOREIGN_KEY_DATA_PREFIX = 'postgres:foreign-key-data:'; + +export interface PostgresForeignKeyDescriptor { + sourceTable: string; + targetTable: string; + constraintName?: string; + sourceColumns: string[]; + targetColumns: string[]; + match?: 'full' | 'partial' | 'simple'; + onDelete?: 'no action' | 'restrict' | 'cascade' | 'set null' | 'set default'; + onUpdate?: 'no action' | 'restrict' | 'cascade' | 'set null' | 'set default'; + deferrable?: boolean; + initially?: 'deferred' | 'immediate'; + notValid?: boolean; +} + +export function encodePostgresForeignKeyDescriptor( + descriptor: PostgresForeignKeyDescriptor +): string { + return `${POSTGRES_FOREIGN_KEY_DATA_PREFIX}${JSON.stringify(descriptor)}`; +} + +export function decodePostgresForeignKeyDescriptor( + decorators: readonly string[] | undefined +): PostgresForeignKeyDescriptor | null { + const encoded = decorators?.find((decorator) => + decorator.startsWith(POSTGRES_FOREIGN_KEY_DATA_PREFIX) + ); + if (!encoded) return null; + + try { + const value = JSON.parse(encoded.slice(POSTGRES_FOREIGN_KEY_DATA_PREFIX.length)) as + Partial; + if ( + typeof value.sourceTable !== 'string' || + typeof value.targetTable !== 'string' || + !Array.isArray(value.sourceColumns) || + !Array.isArray(value.targetColumns) + ) { + return null; + } + return value as PostgresForeignKeyDescriptor; + } catch { + return null; + } +} diff --git a/src/postgres/identifiers.ts b/src/postgres/identifiers.ts new file mode 100644 index 000000000..074cd069b --- /dev/null +++ b/src/postgres/identifiers.ts @@ -0,0 +1,79 @@ +/** Canonical PostgreSQL identifier serialization shared by extraction/resolution. */ + +const SIMPLE_IDENTIFIER = /^[a-z_][a-z0-9_$]*$/; + +/** + * Serialize one already-decoded PostgreSQL identifier without losing segment + * boundaries. PostgreSQL folds unquoted names to lower case, so lower-case + * simple identifiers can stay bare; every other value is quoted and escaped. + */ +export function serializePostgresIdentifier(identifier: string): string { + return SIMPLE_IDENTIFIER.test(identifier) + ? identifier + : `"${identifier.replace(/"/g, '""')}"`; +} + +export function serializePostgresQualifiedName(parts: readonly string[]): string { + return parts.map(serializePostgresIdentifier).join('.'); +} + +/** + * Parse canonical or user-entered PostgreSQL dotted names. Quoted dots remain + * inside their identifier segment and doubled quotes are decoded. + */ +export function parsePostgresQualifiedName(value: string): string[] | null { + const input = value.trim(); + if (!input) return null; + const parts: string[] = []; + let index = 0; + + while (index < input.length) { + while (/\s/.test(input[index] ?? '')) index++; + if (index >= input.length) return null; + + let part = ''; + if (input[index] === '"') { + index++; + let closed = false; + while (index < input.length) { + const char = input[index++]!; + if (char !== '"') { + part += char; + } else if (input[index] === '"') { + part += '"'; + index++; + } else { + closed = true; + break; + } + } + if (!closed || !part) return null; + } else { + const start = index; + while (index < input.length && input[index] !== '.') index++; + part = input.slice(start, index).trim().toLowerCase(); + if (!part || /\s/.test(part)) return null; + } + + while (/\s/.test(input[index] ?? '')) index++; + parts.push(part); + if (index >= input.length) break; + if (input[index] !== '.') return null; + index++; + } + + return parts.length > 0 ? parts : null; +} + +export function appendPostgresIdentifier(qualifiedName: string, identifier: string): string { + return `${qualifiedName}.${serializePostgresIdentifier(identifier)}`; +} + +export function qualifyPostgresName(schema: string, name: string): string | null { + const parts = parsePostgresQualifiedName(name); + return parts ? serializePostgresQualifiedName([schema, ...parts]) : null; +} + +export function isPostgresQualifiedName(name: string): boolean { + return (parsePostgresQualifiedName(name)?.length ?? 0) > 1; +} diff --git a/src/postgres/search-path.ts b/src/postgres/search-path.ts new file mode 100644 index 000000000..2d94fea53 --- /dev/null +++ b/src/postgres/search-path.ts @@ -0,0 +1,485 @@ +/** PostgreSQL search_path parsing shared by extraction and resolution. */ + +export interface PostgresSearchPath { + schemas: string[]; + explicit: boolean; +} + +export interface PostgresSearchPathChange extends PostgresSearchPath { + offset: number; +} + +export interface PostgresSearchPathState { + changes: PostgresSearchPathChange[]; + lineStarts: number[]; +} + +export interface PostgresStatement { + text: string; + endOffset: number; +} + +interface PostgresSavepoint { + name: string; + session: PostgresSearchPath; + local: PostgresSearchPath | null; +} + +const DEFAULT_PATH: PostgresSearchPath = { + // PostgreSQL's literal default is "$user", public. Source indexing does not + // know the runtime role; public is the useful deterministic fallback used by + // migration tooling, while an explicit $user entry remains a shadow barrier. + schemas: ['public'], + explicit: false, +}; + +function dollarTagAt(source: string, offset: number): string | null { + if (source[offset] !== '$') return null; + let end = offset + 1; + if (source[end] === '$') return '$$'; + if (!/[A-Za-z_]/.test(source[end] ?? '')) return null; + end++; + while (/[A-Za-z0-9_]/.test(source[end] ?? '')) end++; + return source[end] === '$' ? source.slice(offset, end + 1) : null; +} + +function clonePath(path: PostgresSearchPath): PostgresSearchPath { + return { schemas: [...path.schemas], explicit: path.explicit }; +} + +function cloneOptionalPath(path: PostgresSearchPath | null): PostgresSearchPath | null { + return path ? clonePath(path) : null; +} + +function decodeSavepointName(raw: string): string { + const value = raw.trim(); + if (value.startsWith('"') && value.endsWith('"')) { + return value.slice(1, -1).replace(/""/g, '"'); + } + return value.toLowerCase(); +} + +function findSavepointIndex(savepoints: PostgresSavepoint[], name: string): number { + for (let index = savepoints.length - 1; index >= 0; index--) { + if (savepoints[index]!.name === name) return index; + } + return -1; +} + +function decodeSingleQuoted(raw: string): string | null { + const value = raw.trim(); + const prefixLength = /^[eE]'/.test(value) ? 1 : 0; + if (value[prefixLength] !== "'" || value[value.length - 1] !== "'") return null; + let decoded = ''; + for (let i = prefixLength + 1; i < value.length - 1; i++) { + const char = value[i]!; + if (char === "'" && value[i + 1] === "'") { + decoded += "'"; + i++; + } else if (prefixLength === 1 && char === '\\' && i + 1 < value.length - 1) { + decoded += value[++i]!; + } else { + decoded += char; + } + } + return decoded; +} + +function decodeDollarQuoted(raw: string): string | null { + const value = raw.trim(); + const opener = dollarTagAt(value, 0); + if (!opener || !value.endsWith(opener) || value.length < opener.length * 2) return null; + return value.slice(opener.length, -opener.length); +} + +function splitIdentifierList(raw: string, recognizeSingleQuotes: boolean): string[] { + const parts: string[] = []; + let current = ''; + let single = false; + let double = false; + let dollarTag: string | null = null; + for (let i = 0; i < raw.length; i++) { + const char = raw[i]!; + if (dollarTag) { + current += char; + if (raw.startsWith(dollarTag, i)) { + current += raw.slice(i + 1, i + dollarTag.length); + i += dollarTag.length - 1; + dollarTag = null; + } + continue; + } + if (single) { + current += char; + if (char === "'" && raw[i + 1] === "'") { + current += raw[++i]!; + } else if (char === "'") { + single = false; + } + continue; + } + if (double) { + current += char; + if (char === '"' && raw[i + 1] === '"') { + current += raw[++i]!; + } else if (char === '"') { + double = false; + } + continue; + } + if (recognizeSingleQuotes && char === "'") { + single = true; + current += char; + } else if (char === '"') { + double = true; + current += char; + } else if (recognizeSingleQuotes && char === '$') { + const tag = dollarTagAt(raw, i); + if (tag) { + dollarTag = tag; + current += tag; + i += tag.length - 1; + } else { + current += char; + } + } else if (char === ',') { + parts.push(current); + current = ''; + } else { + current += char; + } + } + parts.push(current); + return parts; +} + +function decodeIdentifier(part: string, setSyntax: boolean): string | null { + const value = part.trim(); + if (!value) return null; + if (setSyntax) { + const single = decodeSingleQuoted(value); + if (single !== null) return single; + const dollar = decodeDollarQuoted(value); + if (dollar !== null) return dollar; + } + if (value.startsWith('"') && value.endsWith('"')) { + return value.slice(1, -1).replace(/""/g, '"'); + } + return value.toLowerCase(); +} + +function parseSetSearchPath(raw: string): PostgresSearchPath { + const trimmed = raw.trim(); + if (/^default$/i.test(trimmed)) return clonePath(DEFAULT_PATH); + const schemas = splitIdentifierList(trimmed, true) + .map((part) => decodeIdentifier(part, true)) + .filter((schema): schema is string => schema !== null && schema.length > 0); + return { schemas, explicit: true }; +} + +function parseGucSearchPath(rawLiteral: string): PostgresSearchPath | null { + const value = decodeSingleQuoted(rawLiteral) ?? decodeDollarQuoted(rawLiteral); + if (value === null) return null; + const schemas = splitIdentifierList(value, false) + .map((part) => decodeIdentifier(part, false)) + .filter((schema): schema is string => schema !== null && schema.length > 0); + return { schemas, explicit: true }; +} + +function parseSetSchema(rawLiteral: string): PostgresSearchPath | null { + const schema = decodeSingleQuoted(rawLiteral) ?? decodeDollarQuoted(rawLiteral); + if (schema === null) return null; + // SET SCHEMA accepts exactly one string literal. In particular, a comma in + // that literal belongs to the schema name; it is not a search_path separator. + return { schemas: schema.length > 0 ? [schema] : [], explicit: true }; +} + +/** + * Stream top-level statements with bounded buffering. Comments are replaced by + * spaces, quoted bodies suppress semicolon splitting, and pg_dump COPY payloads + * are skipped through their standalone `\.` terminator. + */ +export function* postgresTopLevelStatements(source: string): IterableIterator { + const buffer: string[] = []; + const MAX_STATEMENT_CHARS = 32_768; + let blockDepth = 0; + let lineComment = false; + let single = false; + let escapeString = false; + let double = false; + let dollarTag: string | null = null; + let copyPayload = false; + let statementTail = ''; + + const append = (text: string): void => { + statementTail = (statementTail + text).slice(-512); + if (buffer.length >= MAX_STATEMENT_CHARS) return; + const remaining = MAX_STATEMENT_CHARS - buffer.length; + buffer.push(...text.slice(0, remaining)); + }; + const resetLexicalState = (): void => { + buffer.length = 0; + blockDepth = 0; + lineComment = false; + single = false; + escapeString = false; + double = false; + dollarTag = null; + statementTail = ''; + }; + + for (let i = 0; i < source.length; i++) { + if (copyPayload) { + const newline = source.indexOf('\n', i); + const lineEnd = newline < 0 ? source.length : newline; + const line = source.slice(i, lineEnd).replace(/\r$/, ''); + if (line === '\\.') copyPayload = false; + i = lineEnd; + resetLexicalState(); + continue; + } + + const char = source[i]!; + const next = source[i + 1]; + if (lineComment) { + append(char === '\n' ? '\n' : ' '); + if (char === '\n') lineComment = false; + continue; + } + if (blockDepth > 0) { + append(char === '\n' || char === '\r' ? char : ' '); + if (char === '/' && next === '*') { + append(' '); + blockDepth++; + i++; + } else if (char === '*' && next === '/') { + append(' '); + blockDepth--; + i++; + } + continue; + } + if (dollarTag) { + if (source.startsWith(dollarTag, i)) { + append(dollarTag); + i += dollarTag.length - 1; + dollarTag = null; + } else { + append(char); + } + continue; + } + if (single) { + append(char); + if (char === "'" && next === "'") { + append(next); + i++; + } else if (char === "'") { + single = false; + escapeString = false; + } else if (escapeString && char === '\\' && i + 1 < source.length) { + append(next ?? ''); + i++; + } + continue; + } + if (double) { + append(char); + if (char === '"' && next === '"') { + append(next); + i++; + } else if (char === '"') { + double = false; + } + continue; + } + + if (char === '-' && next === '-') { + append(' '); + lineComment = true; + i++; + } else if (char === '/' && next === '*') { + append(' '); + blockDepth = 1; + i++; + } else if (char === "'") { + append(char); + single = true; + const prefix = source[i - 1]; + const beforePrefix = source[i - 2]; + escapeString = (prefix === 'E' || prefix === 'e') && + (beforePrefix === undefined || !/[A-Za-z0-9_$]/.test(beforePrefix)); + } else if (char === '"') { + append(char); + double = true; + } else if (char === '$' && + (i === 0 || !/[A-Za-z0-9_$]/.test(source[i - 1]!))) { + const tag = dollarTagAt(source, i); + if (tag) { + append(tag); + dollarTag = tag; + i += tag.length - 1; + } else { + append(char); + } + } else { + append(char); + if (char === ';') { + const text = buffer.join(''); + copyPayload = /^\s*COPY\b/i.test(text) && + /\bFROM\s+STDIN\s*;\s*$/i.test(statementTail); + yield { text, endOffset: i + 1 }; + resetLexicalState(); + } + } + } +} + +function samePath(a: PostgresSearchPath, b: PostgresSearchPath): boolean { + return a.explicit === b.explicit && + a.schemas.length === b.schemas.length && + a.schemas.every((schema, index) => schema === b.schemas[index]); +} + +export function analyzePostgresSearchPath(source: string): PostgresSearchPathState { + const changes: PostgresSearchPathChange[] = []; + const lineStarts = [0]; + for (let i = 0; i < source.length; i++) { + if (source[i] === '\n') lineStarts.push(i + 1); + } + + let session = clonePath(DEFAULT_PATH); + let local: PostgresSearchPath | null = null; + let transactionSnapshot: PostgresSearchPath | null = null; + let savepoints: PostgresSavepoint[] = []; + const effective = (): PostgresSearchPath => local ?? session; + const record = (offset: number, before: PostgresSearchPath): void => { + const after = effective(); + if (!samePath(before, after)) changes.push({ offset, ...clonePath(after) }); + }; + + for (const statement of postgresTopLevelStatements(source)) { + const text = statement.text; + const before = clonePath(effective()); + const savepoint = /^\s*SAVEPOINT\s+("(?:""|[^"])+"|[A-Za-z_][A-Za-z0-9_$]*)\s*;\s*$/i + .exec(text); + const rollbackTo = /^\s*ROLLBACK(?:\s+(?:WORK|TRANSACTION))?\s+TO(?:\s+SAVEPOINT)?\s+("(?:""|[^"])+"|[A-Za-z_][A-Za-z0-9_$]*)\s*;\s*$/i + .exec(text); + const release = /^\s*RELEASE(?:\s+SAVEPOINT)?\s+("(?:""|[^"])+"|[A-Za-z_][A-Za-z0-9_$]*)\s*;\s*$/i + .exec(text); + const commit = /^\s*(?:COMMIT|END)(?:\s+(?:WORK|TRANSACTION))?(?:\s+AND\s+(?:NO\s+)?CHAIN)?\s*;\s*$/i + .test(text); + const rollback = /^\s*ROLLBACK(?:\s+(?:WORK|TRANSACTION))?(?:\s+AND\s+(?:NO\s+)?CHAIN)?\s*;\s*$/i + .test(text); + const chains = /\bAND\s+CHAIN\s*;\s*$/i.test(text); + if (/^\s*(?:BEGIN|START\s+TRANSACTION)\b[\s\S]*;\s*$/i.test(text)) { + if (!transactionSnapshot) { + transactionSnapshot = clonePath(session); + savepoints = []; + } + } else if (commit) { + local = null; + savepoints = []; + transactionSnapshot = chains ? clonePath(session) : null; + } else if (rollbackTo) { + const name = decodeSavepointName(rollbackTo[1] ?? ''); + const index = findSavepointIndex(savepoints, name); + if (index >= 0) { + const snapshot = savepoints[index]!; + session = clonePath(snapshot.session); + local = cloneOptionalPath(snapshot.local); + // PostgreSQL keeps the target savepoint active but destroys newer ones. + savepoints.length = index + 1; + } + } else if (rollback) { + if (transactionSnapshot) session = transactionSnapshot; + local = null; + savepoints = []; + transactionSnapshot = chains ? clonePath(session) : null; + } else if (savepoint) { + if (transactionSnapshot) { + savepoints.push({ + name: decodeSavepointName(savepoint[1] ?? ''), + session: clonePath(session), + local: cloneOptionalPath(local), + }); + } + } else if (release) { + const name = decodeSavepointName(release[1] ?? ''); + const index = findSavepointIndex(savepoints, name); + if (index >= 0) savepoints.length = index; + } else { + const set = /^\s*SET\s+(?:(SESSION|LOCAL)\s+)?search_path\s*(?:TO|=)\s*([\s\S]*?)\s*;\s*$/i + .exec(text); + const setSchema = /^\s*SET\s+(?:(SESSION|LOCAL)\s+)?SCHEMA\s+((?:[eE])?'(?:''|\\.|[^'])*'|\$(?:[A-Za-z_][A-Za-z0-9_]*)?\$[\s\S]*\$(?:[A-Za-z_][A-Za-z0-9_]*)?\$)\s*;\s*$/i + .exec(text); + const reset = /^\s*RESET\s+search_path\s*;\s*$/i.test(text); + const setConfig = /^\s*SELECT\s+(?:pg_catalog\.)?set_config\s*\(\s*'search_path'\s*,\s*((?:[eE])?'(?:''|\\.|[^'])*'|\$(?:[A-Za-z_][A-Za-z0-9_]*)?\$[\s\S]*\$(?:[A-Za-z_][A-Za-z0-9_]*)?\$)\s*,\s*(true|false)\s*\)\s*;\s*$/i + .exec(text); + + if (set) { + const nextPath = parseSetSearchPath(set[2] ?? ''); + if (/^LOCAL$/i.test(set[1] ?? '')) { + if (transactionSnapshot) local = nextPath; + } else { + session = nextPath; + local = null; + } + } else if (setSchema) { + const nextPath = parseSetSchema(setSchema[2] ?? ''); + if (nextPath) { + if (/^LOCAL$/i.test(setSchema[1] ?? '')) { + if (transactionSnapshot) local = nextPath; + } else { + session = nextPath; + local = null; + } + } + } else if (reset) { + session = clonePath(DEFAULT_PATH); + local = null; + } else if (setConfig) { + const nextPath = parseGucSearchPath(setConfig[1] ?? ''); + if (nextPath) { + if (/^true$/i.test(setConfig[2] ?? '')) { + if (transactionSnapshot) local = nextPath; + } else { + session = nextPath; + local = null; + } + } + } + } + record(statement.endOffset, before); + } + return { changes, lineStarts }; +} + +export function postgresSearchPathAtOffset( + state: PostgresSearchPathState, + offset: number +): PostgresSearchPath { + let low = 0; + let high = state.changes.length - 1; + let found = -1; + while (low <= high) { + const middle = (low + high) >>> 1; + if (state.changes[middle]!.offset <= offset) { + found = middle; + low = middle + 1; + } else { + high = middle - 1; + } + } + return found >= 0 ? state.changes[found]! : DEFAULT_PATH; +} + +export function postgresOffsetAtPosition( + state: PostgresSearchPathState, + line: number, + column: number +): number { + const lineStart = state.lineStarts[Math.max(0, line - 1)] ?? + state.lineStarts[state.lineStarts.length - 1] ?? 0; + return lineStart + Math.max(0, column); +} diff --git a/src/postgres/table-relation.ts b/src/postgres/table-relation.ts new file mode 100644 index 000000000..d49f7ed2b --- /dev/null +++ b/src/postgres/table-relation.ts @@ -0,0 +1,49 @@ +/** Shared encoding for PostgreSQL structural table-relation facts. */ + +export const POSTGRES_TABLE_RELATION_DECORATOR = 'postgres:table-relation'; +export const POSTGRES_TABLE_RELATION_DATA_PREFIX = 'postgres:table-relation-data:'; + +export type PostgresTableRelationKind = + | 'partition-of' + | 'inherits' + | 'like' + | 'attach-partition' + | 'detach-partition' + | 'inherit' + | 'no-inherit' + | 'constraint-trigger'; + +export interface PostgresTableRelationDescriptor { + relation: PostgresTableRelationKind; + sourceTable: string; + targetTable: string; + mode?: 'concurrently' | 'finalize'; + triggerName?: string; +} + +export function encodePostgresTableRelationDescriptor( + descriptor: PostgresTableRelationDescriptor +): string { + return `${POSTGRES_TABLE_RELATION_DATA_PREFIX}${JSON.stringify(descriptor)}`; +} + +export function decodePostgresTableRelationDescriptor( + decorators: readonly string[] | undefined +): PostgresTableRelationDescriptor | null { + const encoded = decorators?.find((decorator) => + decorator.startsWith(POSTGRES_TABLE_RELATION_DATA_PREFIX) + ); + if (!encoded) return null; + try { + const value = JSON.parse(encoded.slice(POSTGRES_TABLE_RELATION_DATA_PREFIX.length)) as + Partial; + if ( + typeof value.relation !== 'string' || + typeof value.sourceTable !== 'string' || + typeof value.targetTable !== 'string' + ) return null; + return value as PostgresTableRelationDescriptor; + } catch { + return null; + } +} diff --git a/src/postgres/temporary-relations.ts b/src/postgres/temporary-relations.ts new file mode 100644 index 000000000..f7e754736 --- /dev/null +++ b/src/postgres/temporary-relations.ts @@ -0,0 +1,375 @@ +import type { Node } from '../types'; +import { parsePostgresQualifiedName } from './identifiers'; +import { + postgresOffsetAtPosition, + postgresTopLevelStatements, + type PostgresSearchPathState, +} from './search-path'; + +interface VisibilityChange { + offset: number; + visible: boolean; +} + +export interface PostgresTemporaryRelationVisibilityState { + changesByNodeId: Map; +} + +interface TemporaryDeclaration { + node: Node; + endOffset: number; + onCommitDrop: boolean; +} + +interface TemporarySavepoint { + name: string; + visible: Map; +} + +function dollarTagAt(source: string, offset: number): string | null { + if (source[offset] !== '$') return null; + let end = offset + 1; + if (source[end] === '$') return '$$'; + if (!/[A-Za-z_]/.test(source[end] ?? '')) return null; + end++; + while (/[A-Za-z0-9_]/.test(source[end] ?? '')) end++; + return source[end] === '$' ? source.slice(offset, end + 1) : null; +} + +/** Match a real ON COMMIT DROP clause, not the same words in a literal. */ +function hasOnCommitDrop(source: string): boolean { + let searchable = ''; + let single = false; + let double = false; + let dollarTag: string | null = null; + let lineComment = false; + let blockDepth = 0; + + for (let index = 0; index < source.length; index++) { + const char = source[index]!; + const next = source[index + 1]; + if (lineComment) { + searchable += char === '\n' ? '\n' : ' '; + if (char === '\n') lineComment = false; + continue; + } + if (blockDepth > 0) { + searchable += char === '\n' ? '\n' : ' '; + if (char === '/' && next === '*') { + searchable += ' '; + blockDepth++; + index++; + } else if (char === '*' && next === '/') { + searchable += ' '; + blockDepth--; + index++; + } + continue; + } + if (dollarTag) { + searchable += ' '; + if (source.startsWith(dollarTag, index)) { + searchable += ' '.repeat(dollarTag.length - 1); + index += dollarTag.length - 1; + dollarTag = null; + } + continue; + } + if (single) { + searchable += ' '; + if (char === "'" && next === "'") { + searchable += ' '; + index++; + } else if (char === "'") { + single = false; + } else if (char === '\\' && index + 1 < source.length) { + searchable += ' '; + index++; + } + continue; + } + if (double) { + searchable += ' '; + if (char === '"' && next === '"') { + searchable += ' '; + index++; + } else if (char === '"') { + double = false; + } + continue; + } + if (char === '-' && next === '-') { + searchable += ' '; + lineComment = true; + index++; + } else if (char === '/' && next === '*') { + searchable += ' '; + blockDepth = 1; + index++; + } else if (char === "'") { + searchable += ' '; + single = true; + } else if (char === '"') { + searchable += ' '; + double = true; + } else if (char === '$') { + const tag = dollarTagAt(source, index); + if (tag) { + searchable += ' '.repeat(tag.length); + dollarTag = tag; + index += tag.length - 1; + } else { + searchable += char; + } + } else { + searchable += char; + } + } + + return /\bON\s+COMMIT\s+DROP\b/i.test(searchable); +} + +function splitDropTargets(raw: string): string[] { + const result: string[] = []; + let current = ''; + let quoted = false; + for (let index = 0; index < raw.length; index++) { + const char = raw[index]!; + if (char === '"') { + current += char; + if (quoted && raw[index + 1] === '"') { + current += raw[++index]!; + } else { + quoted = !quoted; + } + } else if (char === ',' && !quoted) { + result.push(current.trim()); + current = ''; + } else { + current += char; + } + } + if (current.trim()) result.push(current.trim()); + return result; +} + +function temporaryDropKind(node: Node): string | null { + if (node.decorators?.includes('postgres:table')) return 'table'; + if (node.decorators?.includes('postgres:view')) return 'view'; + if (node.decorators?.includes('postgres:sequence')) return 'sequence'; + return null; +} + +function dropTargets(statement: string): { kind: string; names: string[][] } | null { + const match = /^\s*DROP\s+(TABLE|VIEW|SEQUENCE)\s+(?:IF\s+EXISTS\s+)?([\s\S]*?)\s*;\s*$/i + .exec(statement); + if (!match) return null; + const body = (match[2] ?? '').replace(/\s+(?:CASCADE|RESTRICT)\s*$/i, ''); + const names = splitDropTargets(body) + .map((target) => parsePostgresQualifiedName(target)) + .filter((parts): parts is string[] => parts !== null); + return { kind: (match[1] ?? '').toLowerCase(), names }; +} + +function dropMatches(node: Node, drop: { kind: string; names: string[][] }): boolean { + if (temporaryDropKind(node) !== drop.kind) return false; + const candidate = parsePostgresQualifiedName(node.qualifiedName); + if (!candidate || candidate.length < 2) return false; + const simple = candidate[candidate.length - 1]!; + return drop.names.some((target) => { + if (target.length === 1) return target[0] === simple; + if (target.length !== candidate.length) return false; + const targetSchema = target[0]; + const candidateSchema = candidate[0]; + const sameTemporarySchema = targetSchema === 'pg_temp' && + (candidateSchema === 'pg_temp' || /^pg_temp_[0-9]+$/.test(candidateSchema ?? '')); + return (sameTemporarySchema || targetSchema === candidateSchema) && + target.slice(1).every((part, index) => part === candidate[index + 1]); + }); +} + +function isBegin(statement: string): boolean { + return /^\s*(?:BEGIN|START\s+TRANSACTION)\b[\s\S]*;\s*$/i.test(statement); +} + +function isCommit(statement: string): boolean { + return /^\s*(?:COMMIT|END)(?:\s+(?:WORK|TRANSACTION))?(?:\s+AND\s+(?:NO\s+)?CHAIN)?\s*;\s*$/i + .test(statement); +} + +function isRollback(statement: string): boolean { + return /^\s*ROLLBACK(?:\s+(?:WORK|TRANSACTION))?(?:\s+AND\s+(?:NO\s+)?CHAIN)?\s*;\s*$/i + .test(statement); +} + +function chains(statement: string): boolean { + return /\bAND\s+CHAIN\s*;\s*$/i.test(statement); +} + +function decodeSavepointName(raw: string): string { + const value = raw.trim(); + if (value.startsWith('"') && value.endsWith('"')) { + return value.slice(1, -1).replace(/""/g, '"'); + } + return value.toLowerCase(); +} + +function findSavepointIndex(savepoints: TemporarySavepoint[], name: string): number { + for (let index = savepoints.length - 1; index >= 0; index--) { + if (savepoints[index]!.name === name) return index; + } + return -1; +} + +/** + * Build statement-ordered visibility timelines for temporary relations in one + * SQL file. Effects become visible at statement completion. Transactional + * CREATE/DROP is restored by ROLLBACK, while ON COMMIT DROP is applied only by + * an actual or implicit commit. + */ +export function analyzePostgresTemporaryRelationVisibility( + source: string, + nodes: readonly Node[], + positions: PostgresSearchPathState +): PostgresTemporaryRelationVisibilityState { + const declarations: TemporaryDeclaration[] = nodes + .filter((node) => node.language === 'postgres' && + node.decorators?.includes('postgres:temporary') === true) + .map((node) => { + const startOffset = postgresOffsetAtPosition( + positions, + node.startLine, + node.startColumn + ); + const endOffset = postgresOffsetAtPosition(positions, node.endLine, node.endColumn); + return { + node, + endOffset, + onCommitDrop: hasOnCommitDrop(source.slice(startOffset, endOffset)), + }; + }) + .sort((left, right) => left.endOffset - right.endOffset || + left.node.id.localeCompare(right.node.id)); + + const changesByNodeId = new Map(); + const visible = new Map(); + let transactionSnapshot: Map | null = null; + let savepoints: TemporarySavepoint[] = []; + let declarationIndex = 0; + + const record = (declaration: TemporaryDeclaration, value: boolean, offset: number): void => { + const previous = visible.get(declaration.node.id) ?? false; + if (previous === value) return; + visible.set(declaration.node.id, value); + let changes = changesByNodeId.get(declaration.node.id); + if (!changes) { + changes = []; + changesByNodeId.set(declaration.node.id, changes); + } + changes.push({ offset, visible: value }); + }; + + const snapshot = (): Map => new Map(visible); + const restore = (state: Map, offset: number): void => { + for (const declaration of declarations) { + record(declaration, state.get(declaration.node.id) ?? false, offset); + } + }; + + const declareThrough = (endOffset: number): void => { + while (declarationIndex < declarations.length && + declarations[declarationIndex]!.endOffset <= endOffset) { + const declaration = declarations[declarationIndex++]!; + if (transactionSnapshot) { + record(declaration, true, endOffset); + } else if (!declaration.onCommitDrop) { + record(declaration, true, endOffset); + } + } + }; + + for (const statement of postgresTopLevelStatements(source)) { + const text = statement.text; + const savepoint = /^\s*SAVEPOINT\s+("(?:""|[^"])+"|[A-Za-z_][A-Za-z0-9_$]*)\s*;\s*$/i + .exec(text); + const rollbackTo = /^\s*ROLLBACK(?:\s+(?:WORK|TRANSACTION))?\s+TO(?:\s+SAVEPOINT)?\s+("(?:""|[^"])+"|[A-Za-z_][A-Za-z0-9_$]*)\s*;\s*$/i + .exec(text); + const release = /^\s*RELEASE(?:\s+SAVEPOINT)?\s+("(?:""|[^"])+"|[A-Za-z_][A-Za-z0-9_$]*)\s*;\s*$/i + .exec(text); + if (isBegin(text)) { + if (!transactionSnapshot) { + transactionSnapshot = snapshot(); + savepoints = []; + } + } else if (isCommit(text)) { + for (const declaration of declarations) { + if (declaration.onCommitDrop && visible.get(declaration.node.id) === true) { + record(declaration, false, statement.endOffset); + } + } + savepoints = []; + transactionSnapshot = chains(text) ? snapshot() : null; + } else if (rollbackTo) { + const name = decodeSavepointName(rollbackTo[1] ?? ''); + const index = findSavepointIndex(savepoints, name); + if (index >= 0) { + restore(savepoints[index]!.visible, statement.endOffset); + // The target remains active; later savepoints are destroyed. + savepoints.length = index + 1; + } + } else if (isRollback(text)) { + if (transactionSnapshot) restore(transactionSnapshot, statement.endOffset); + savepoints = []; + transactionSnapshot = chains(text) ? snapshot() : null; + } else if (savepoint) { + if (transactionSnapshot) { + savepoints.push({ + name: decodeSavepointName(savepoint[1] ?? ''), + visible: snapshot(), + }); + } + } else if (release) { + const name = decodeSavepointName(release[1] ?? ''); + const index = findSavepointIndex(savepoints, name); + if (index >= 0) savepoints.length = index; + } else { + const drop = dropTargets(text); + if (drop) { + for (const declaration of declarations) { + if (visible.get(declaration.node.id) === true && dropMatches(declaration.node, drop)) { + record(declaration, false, statement.endOffset); + } + } + } + } + declareThrough(statement.endOffset); + } + + // A final statement does not require a semicolon. Its declarations become + // visible at EOF under the same implicit-transaction rule. The node range is + // also a fallback when a minimal ResolutionContext cannot provide source. + declareThrough(Math.max(source.length, declarations.at(-1)?.endOffset ?? 0)); + return { changesByNodeId }; +} + +export function postgresTemporaryRelationVisibleAt( + state: PostgresTemporaryRelationVisibilityState, + nodeId: string, + offset: number +): boolean { + const changes = state.changesByNodeId.get(nodeId); + if (!changes) return false; + let low = 0; + let high = changes.length - 1; + let found = -1; + while (low <= high) { + const middle = (low + high) >>> 1; + if (changes[middle]!.offset <= offset) { + found = middle; + low = middle + 1; + } else { + high = middle - 1; + } + } + return found >= 0 && changes[found]!.visible; +} diff --git a/src/resolution/callback-synthesizer.ts b/src/resolution/callback-synthesizer.ts index b8bc1045a..a11b2cf8d 100644 --- a/src/resolution/callback-synthesizer.ts +++ b/src/resolution/callback-synthesizer.ts @@ -3590,7 +3590,7 @@ export const SYNTH_PASSES: SynthPassDef[] = [ { name: 'nixOptionEdges', gate: (has) => has('nix'), run: (q, _c, y) => nixOptionPathEdges(q, y) }, ]; -/** Fixed non-registry steps: goMethodContains, goImplements, dedupe-merge, insertMergedEdges. */ +/** Fixed non-registry steps: Go relationships, merge, and insert. */ const FIXED_SYNTH_STEPS = 4; export const SYNTH_PROGRESS_STEPS = SYNTH_PASSES.length + FIXED_SYNTH_STEPS; export async function synthesizeCallbackEdges( diff --git a/src/resolution/index.ts b/src/resolution/index.ts index 598e5e479..46e5f26e6 100644 --- a/src/resolution/index.ts +++ b/src/resolution/index.ts @@ -21,6 +21,14 @@ import { resolveViaImport, resolveJvmImport, extractImportMappings, extractReExp import { ResolverPool, minRefsForPool } from './resolver-pool'; import { detectFrameworks } from './frameworks'; import { synthesizeCallbackEdges } from './callback-synthesizer'; +import { + refreshPostgresForeignKeyEdges, + refreshPostgresForeignKeyEdgesSync, +} from './postgres-foreign-key-synthesizer'; +import { + refreshPostgresStructureEdges, + refreshPostgresStructureEdgesSync, +} from './postgres-structure-synthesizer'; import { createYielder, type MaybeYield } from './cooperative-yield'; import { loadProjectAliases, type AliasMap } from './path-aliases'; import { loadGoModule, type GoModule } from './go-module'; @@ -1936,6 +1944,20 @@ export class ReferenceResolver { // synthesis is additive and optional; ignore failures } if (process.env.CODEGRAPH_SYNTH_TIMINGS) console.error(`[phase-timing] callback-synthesis: ${Date.now() - tSynth}ms`); + + // PostgreSQL FK table edges are an exact, owned projection of resolved + // constraint endpoints, not a best-effort heuristic. Keep this outside the + // callback-synthesis catch so failure propagates and a caller never marks + // an index complete with stale/missing FK relationships. A state + // fingerprint makes the common unchanged path a single join and no writes. + const tPostgresFk = Date.now(); + aggregateStats.byMethod['postgres-foreign-key-synthesis'] = + await refreshPostgresForeignKeyEdges(this.queries, createYielder()); + aggregateStats.byMethod['postgres-structure-synthesis'] = + await refreshPostgresStructureEdges(this.queries, createYielder()); + if (process.env.CODEGRAPH_SYNTH_TIMINGS) { + console.error(`[phase-timing] postgres-foreign-key-synthesis: ${Date.now() - tPostgresFk}ms`); + } } finally { if (pool) await pool.destroy().catch(() => undefined); } @@ -2432,6 +2454,19 @@ export class ReferenceResolver { if (tgt && ref.language && crossesKnownFamily(tgt, ref.language)) return null; return result; } + + /** Refresh exact PostgreSQL relationship projections after resolution. */ + async refreshPostgresForeignKeys(): Promise { + const yielder = createYielder(); + return await refreshPostgresForeignKeyEdges(this.queries, yielder) + + await refreshPostgresStructureEdges(this.queries, yielder); + } + + /** Synchronous refresh used by CodeGraph.resolveReferences(). */ + refreshPostgresForeignKeysSync(): number { + return refreshPostgresForeignKeyEdgesSync(this.queries) + + refreshPostgresStructureEdgesSync(this.queries); + } } /** diff --git a/src/resolution/name-matcher.ts b/src/resolution/name-matcher.ts index 3546b3d23..c72d9bcec 100644 --- a/src/resolution/name-matcher.ts +++ b/src/resolution/name-matcher.ts @@ -5,6 +5,22 @@ */ import { Language, Node } from '../types'; +import { + analyzePostgresSearchPath, + postgresOffsetAtPosition, + postgresSearchPathAtOffset as sharedPostgresSearchPathAtOffset, + type PostgresSearchPathState as SharedPostgresSearchPathState, +} from '../postgres/search-path'; +import { + isPostgresQualifiedName, + parsePostgresQualifiedName, + qualifyPostgresName, +} from '../postgres/identifiers'; +import { + analyzePostgresTemporaryRelationVisibility, + postgresTemporaryRelationVisibleAt, + type PostgresTemporaryRelationVisibilityState, +} from '../postgres/temporary-relations'; import { UnresolvedRef, ResolvedRef, ResolutionContext } from './types'; /** @@ -357,10 +373,58 @@ export function matchFunctionRef( * - callable references target decorated routines only; relation references * target relation-like (`struct`) nodes only. * - * Ambiguity is left unresolved. A future PostgreSQL-aware resolver can add - * search_path and migration-order semantics without weakening this precision - * floor. + * Unqualified references honor top-level SET/RESET search_path state (with + * PostgreSQL's default public fallback). Duplicate historical definitions are + * still left unresolved until an ordered-migration model can distinguish them. */ +const POSTGRES_SEARCH_PATH_CACHE = new WeakMap< + ResolutionContext, + Map +>(); +const POSTGRES_TEMPORARY_VISIBILITY_CACHE = new WeakMap< + ResolutionContext, + Map +>(); + +function postgresSearchPathState( + context: ResolutionContext, + filePath: string +): SharedPostgresSearchPathState { + let byFile = POSTGRES_SEARCH_PATH_CACHE.get(context); + if (!byFile) { + byFile = new Map(); + POSTGRES_SEARCH_PATH_CACHE.set(context, byFile); + } + const cached = byFile.get(filePath); + if (cached) return cached; + + const state = analyzePostgresSearchPath(context.readFile(filePath) ?? ''); + byFile.set(filePath, state); + return state; +} + +function postgresTemporaryVisibilityState( + context: ResolutionContext, + filePath: string, + positions: SharedPostgresSearchPathState +): PostgresTemporaryRelationVisibilityState { + let byFile = POSTGRES_TEMPORARY_VISIBILITY_CACHE.get(context); + if (!byFile) { + byFile = new Map(); + POSTGRES_TEMPORARY_VISIBILITY_CACHE.set(context, byFile); + } + const cached = byFile.get(filePath); + if (cached) return cached; + + const state = analyzePostgresTemporaryRelationVisibility( + context.readFile(filePath) ?? '', + context.getNodesInFile(filePath), + positions + ); + byFile.set(filePath, state); + return state; +} + export function matchPostgresReference( ref: UnresolvedRef, context: ResolutionContext @@ -368,8 +432,24 @@ export function matchPostgresReference( if (ref.language !== 'postgres') return null; const isCallable = ref.referenceKind === 'calls' || ref.referenceKind === 'function_ref'; + const positions = postgresSearchPathState(context, ref.filePath); + const refOffset = postgresOffsetAtPosition(positions, ref.line, ref.column); + let temporaryVisibility: PostgresTemporaryRelationVisibilityState | null = null; const eligible = (node: Node): boolean => { if (node.language !== 'postgres') return false; + // `pg_temp` is a per-session alias. A temp object extracted from another + // migration file cannot safely satisfy this file's reference. + if (node.decorators?.includes('postgres:temporary') === true) { + if (node.filePath !== ref.filePath) return false; + temporaryVisibility ??= postgresTemporaryVisibilityState( + context, + ref.filePath, + positions + ); + if (!postgresTemporaryRelationVisibleAt(temporaryVisibility, node.id, refOffset)) { + return false; + } + } if (isCallable) { return node.kind === 'function' && ( node.decorators?.includes('postgres:function') === true || @@ -379,23 +459,64 @@ export function matchPostgresReference( return node.kind === 'struct'; }; - const isQualified = ref.referenceName.includes('::') || ref.referenceName.includes('.'); - const candidates = (isQualified - ? context.getNodesByQualifiedName(ref.referenceName) - : context.getNodesByName(ref.referenceName) - ).filter(eligible); - if (candidates.length === 0) return null; + const parsedReference = parsePostgresQualifiedName(ref.referenceName); + const referenceSimple = parsedReference?.[parsedReference.length - 1] ?? ref.referenceName; + const isQualified = ref.referenceName.includes('::') || + isPostgresQualifiedName(ref.referenceName); + const pick = (candidates: Node[]): Node | undefined => { + const sameFile = candidates.filter((node) => node.filePath === ref.filePath); + if (sameFile.length === 1) return sameFile[0]; + if (sameFile.length > 1) return undefined; + return candidates.length === 1 ? candidates[0] : undefined; + }; - const sameFile = candidates.filter((node) => node.filePath === ref.filePath); let target: Node | undefined; - if (sameFile.length === 1) { - target = sameFile[0]; - } else if (sameFile.length > 1) { - return null; - } else if (candidates.length === 1) { - target = candidates[0]; + if (isQualified) { + const candidates = context.getNodesByQualifiedName(ref.referenceName).filter(eligible); + target = pick(candidates); } else { - return null; + const searchPath = sharedPostgresSearchPathAtOffset(positions, refOffset); + let foundInSearchPath = false; + if (!isCallable) { + const temporaryName = qualifyPostgresName('pg_temp', ref.referenceName); + const temporaryCandidates = temporaryName + ? context.getNodesByQualifiedName(temporaryName).filter(eligible) + : []; + if (temporaryCandidates.length > 0) { + foundInSearchPath = true; + target = pick(temporaryCandidates); + } + } + for (const schema of searchPath.schemas) { + if (foundInSearchPath) break; + // The runtime role behind $user is unknowable from source. It shadows + // later schemas when present, so choosing a later candidate would invent + // certainty; leave the reference unresolved instead. + if (schema === '$user') { + foundInSearchPath = true; + break; + } + const qualified = qualifyPostgresName(schema, ref.referenceName); + const schemaCandidates = [ + ...(qualified ? context.getNodesByQualifiedName(qualified) : []), + ...context.getNodesByQualifiedName(`${schema}::${ref.referenceName}`), + ].filter(eligible); + if (schemaCandidates.length === 0) continue; + // The first schema containing the name shadows every later schema. If + // that schema has duplicate historical definitions, preserve ambiguity. + foundInSearchPath = true; + target = pick(schemaCandidates); + break; + } + + if (!target && !foundInSearchPath) { + const candidates = context.getNodesByName(referenceSimple).filter(eligible); + // Never jump to a qualified schema outside the active path. A uniquely + // unqualified declaration is retained for extractor backward + // compatibility (CREATE TABLE users before schema-aware declarations). + const fallback = candidates.filter((node) => node.qualifiedName === ref.referenceName); + target = pick(fallback); + } } if (!target) return null; @@ -1243,6 +1364,7 @@ function getInferScanStates(context: ResolutionContext): Map RegExp[]): RegExp[] { diff --git a/src/resolution/postgres-foreign-key-synthesizer.ts b/src/resolution/postgres-foreign-key-synthesizer.ts new file mode 100644 index 000000000..e74981cfd --- /dev/null +++ b/src/resolution/postgres-foreign-key-synthesizer.ts @@ -0,0 +1,250 @@ +import { createHash } from 'node:crypto'; +import type { Edge, Node } from '../types'; +import type { QueryBuilder } from '../db/queries'; +import { + POSTGRES_FOREIGN_KEY_DECORATOR, + decodePostgresForeignKeyDescriptor, + type PostgresForeignKeyDescriptor, +} from '../postgres/foreign-key'; +import { isPostgresQualifiedName } from '../postgres/identifiers'; +import type { MaybeYield } from './cooperative-yield'; + +export const POSTGRES_FOREIGN_KEY_SYNTHESIZER = 'postgres-foreign-key'; +export const POSTGRES_FOREIGN_KEY_FINGERPRINT_METADATA = + 'postgres_foreign_key_state_fingerprint'; + +interface ConstraintFact extends PostgresForeignKeyDescriptor { + filePath: string; + line: number; +} + +interface ForeignKeyGroup { + source: Node; + target: Node; + constraints: ConstraintFact[]; + line: number; +} + +function isTable(node: Node | null): node is Node { + return node?.language === 'postgres' && node.kind === 'struct' && ( + node.decorators?.includes('postgres:table') === true || + node.decorators?.includes('postgres:foreign-table') === true + ); +} + +interface ResolvedEndpoint { + node: Node; + refName: string | undefined; +} + +function resolvedEndpoint( + endpoints: ResolvedEndpoint[], + name: string +): Node | null { + // `refName` preserves which of the FK fact's two references produced an + // edge. Node-name matching alone cannot distinguish `audit.users` (source) + // from an unqualified `users` target resolved through search_path. + let matches = endpoints + .filter((endpoint) => endpoint.refName === name) + .map((endpoint) => endpoint.node); + if (matches.length === 0) { + const qualified = isPostgresQualifiedName(name); + matches = endpoints + .map((endpoint) => endpoint.node) + .filter((node) => qualified ? node.qualifiedName === name : node.name === name); + } + const unique = new Map(matches.map((node) => [node.id, node])); + return unique.size === 1 ? unique.values().next().value ?? null : null; +} + +/** + * Convert resolved constraint endpoints into the relationship users expect to + * traverse: source table -> referenced table. Several constraints between the + * same pair are aggregated on one edge rather than multiplying graph paths. + */ +function collectForeignKey( + grouped: Map, + queries: QueryBuilder, + foreignKey: Node +): void { + if (!foreignKey.decorators?.includes(POSTGRES_FOREIGN_KEY_DECORATOR)) return; + const descriptor = decodePostgresForeignKeyDescriptor(foreignKey.decorators); + if (!descriptor) return; + + const endpoints = queries + .getOutgoingEdges(foreignKey.id, ['references']) + .map((edge) => ({ + node: queries.getNodeById(edge.target), + refName: typeof edge.metadata?.refName === 'string' ? edge.metadata.refName : undefined, + })) + .filter((endpoint): endpoint is ResolvedEndpoint => isTable(endpoint.node)); + const source = resolvedEndpoint(endpoints, descriptor.sourceTable); + const target = resolvedEndpoint(endpoints, descriptor.targetTable); + if (!source || !target) return; + + const key = `${source.id}\u0000${target.id}`; + const fact: ConstraintFact = { + ...descriptor, + filePath: foreignKey.filePath, + line: foreignKey.startLine, + }; + const existing = grouped.get(key); + if (existing) { + existing.constraints.push(fact); + existing.line = Math.min(existing.line, foreignKey.startLine); + } else { + grouped.set(key, { + source, + target, + constraints: [fact], + line: foreignKey.startLine, + }); + } +} + +function materializeForeignKeyEdges(grouped: Map): Edge[] { + return [...grouped.values()].map(({ source, target, constraints, line }) => ({ + source: source.id, + target: target.id, + kind: 'references', + line, + provenance: 'tree-sitter', + metadata: { + synthesizedBy: POSTGRES_FOREIGN_KEY_SYNTHESIZER, + postgresRelation: 'foreign-key', + constraints: constraints.sort((a, b) => + a.filePath.localeCompare(b.filePath) || a.line - b.line + ), + }, + })); +} + +function postgresForeignKeyStateFingerprint( + queries: QueryBuilder +): { fingerprint: string; factCount: number } { + const hash = createHash('sha256'); + let factCount = 0; + let previousNodeId: string | null = null; + for (const row of queries.iterateDecoratorReferenceState( + 'postgres', + POSTGRES_FOREIGN_KEY_DECORATOR + )) { + if (row.nodeId !== previousNodeId) { + factCount++; + previousNodeId = row.nodeId; + } + hash.update(JSON.stringify([ + row.nodeId, + row.decorators, + row.targetId, + row.edgeMetadata, + row.targetQualifiedName, + row.targetKind, + row.targetLanguage, + row.targetDecorators, + ])); + hash.update('\n'); + } + return { fingerprint: `v2:${hash.digest('hex')}`, factCount }; +} + +function postgresForeignKeyOutputFingerprint( + queries: QueryBuilder +): { fingerprint: string; edgeCount: number } { + const hash = createHash('sha256'); + let edgeCount = 0; + for (const edge of queries.iterateEdgesBySynthesizer(POSTGRES_FOREIGN_KEY_SYNTHESIZER)) { + edgeCount++; + hash.update(JSON.stringify([ + edge.source, + edge.target, + edge.kind, + edge.metadata, + edge.line, + edge.col, + edge.provenance, + ])); + hash.update('\n'); + } + return { fingerprint: `v1:${hash.digest('hex')}`, edgeCount }; +} + +function persistedFingerprint(input: string, output: string): string { + return `input=${input};output=${output}`; +} + +function persistCurrentFingerprint( + queries: QueryBuilder, + input: { fingerprint: string; factCount: number } +): void { + const output = postgresForeignKeyOutputFingerprint(queries); + if (input.factCount === 0 && output.edgeCount === 0) { + queries.deleteMetadata(POSTGRES_FOREIGN_KEY_FINGERPRINT_METADATA); + } else { + queries.setMetadata( + POSTGRES_FOREIGN_KEY_FINGERPRINT_METADATA, + persistedFingerprint(input.fingerprint, output.fingerprint) + ); + } +} + +export function postgresForeignKeyEdgesSync(queries: QueryBuilder): Edge[] { + const grouped = new Map(); + for (const foreignKey of queries.iterateNodesByLanguageWithDecorator( + 'postgres', + POSTGRES_FOREIGN_KEY_DECORATOR + )) { + collectForeignKey(grouped, queries, foreignKey); + } + return materializeForeignKeyEdges(grouped); +} + +export async function postgresForeignKeyEdges( + queries: QueryBuilder, + onYield: MaybeYield +): Promise { + const grouped = new Map(); + let scanned = 0; + for (const foreignKey of queries.iterateNodesByLanguageWithDecorator( + 'postgres', + POSTGRES_FOREIGN_KEY_DECORATOR + )) { + if ((++scanned & 127) === 0) await onYield(); + collectForeignKey(grouped, queries, foreignKey); + } + + return materializeForeignKeyEdges(grouped); +} + +/** Atomically refresh the owned edge set after facts are resolved. */ +export async function refreshPostgresForeignKeyEdges( + queries: QueryBuilder, + onYield: MaybeYield +): Promise { + const state = postgresForeignKeyStateFingerprint(queries); + const output = postgresForeignKeyOutputFingerprint(queries); + const previous = queries.getMetadata(POSTGRES_FOREIGN_KEY_FINGERPRINT_METADATA); + if (state.factCount === 0 && output.edgeCount === 0 && previous === null) return 0; + if (previous === persistedFingerprint(state.fingerprint, output.fingerprint)) return 0; + + // Compute first so a parser/query failure leaves the last complete edge set. + const edges = await postgresForeignKeyEdges(queries, onYield); + queries.replaceEdgesBySynthesizer(POSTGRES_FOREIGN_KEY_SYNTHESIZER, edges); + persistCurrentFingerprint(queries, state); + await onYield(); + return edges.length; +} + +/** Synchronous counterpart for the public synchronous resolution API. */ +export function refreshPostgresForeignKeyEdgesSync(queries: QueryBuilder): number { + const state = postgresForeignKeyStateFingerprint(queries); + const output = postgresForeignKeyOutputFingerprint(queries); + const previous = queries.getMetadata(POSTGRES_FOREIGN_KEY_FINGERPRINT_METADATA); + if (state.factCount === 0 && output.edgeCount === 0 && previous === null) return 0; + if (previous === persistedFingerprint(state.fingerprint, output.fingerprint)) return 0; + + const edges = postgresForeignKeyEdgesSync(queries); + queries.replaceEdgesBySynthesizer(POSTGRES_FOREIGN_KEY_SYNTHESIZER, edges); + persistCurrentFingerprint(queries, state); + return edges.length; +} diff --git a/src/resolution/postgres-structure-synthesizer.ts b/src/resolution/postgres-structure-synthesizer.ts new file mode 100644 index 000000000..5c2434306 --- /dev/null +++ b/src/resolution/postgres-structure-synthesizer.ts @@ -0,0 +1,262 @@ +import { createHash } from 'node:crypto'; +import type { Edge, Node } from '../types'; +import type { QueryBuilder } from '../db/queries'; +import { + parsePostgresQualifiedName, + serializePostgresQualifiedName, + isPostgresQualifiedName, +} from '../postgres/identifiers'; +import { + POSTGRES_TABLE_RELATION_DECORATOR, + decodePostgresTableRelationDescriptor, + type PostgresTableRelationDescriptor, +} from '../postgres/table-relation'; +import type { MaybeYield } from './cooperative-yield'; + +export const POSTGRES_STRUCTURE_SYNTHESIZER = 'postgres-structure'; +const POSTGRES_STRUCTURE_FINGERPRINT_METADATA = 'postgres_structure_state_fingerprint'; + +interface ResolvedEndpoint { + node: Node; + refName: string | undefined; +} + +interface RelationFact extends PostgresTableRelationDescriptor { + filePath: string; + line: number; + column: number; +} + +const SCHEMA_OBJECT_DECORATORS = new Set([ + 'postgres:table', + 'postgres:foreign-table', + 'postgres:view', + 'postgres:materialized-view', + 'postgres:function', + 'postgres:procedure', + 'postgres:type', + 'postgres:enum', + 'postgres:domain', + 'postgres:sequence', + 'postgres:index', +]); + +function isTable(node: Node | null): node is Node { + return node?.language === 'postgres' && node.kind === 'struct' && ( + node.decorators?.includes('postgres:table') === true || + node.decorators?.includes('postgres:foreign-table') === true + ); +} + +function resolvedEndpoint(endpoints: ResolvedEndpoint[], name: string): Node | null { + let matches = endpoints + .filter((endpoint) => endpoint.refName === name) + .map((endpoint) => endpoint.node); + if (matches.length === 0) { + const qualified = isPostgresQualifiedName(name); + const parsed = parsePostgresQualifiedName(name); + const simple = parsed?.[parsed.length - 1] ?? name; + matches = endpoints + .map((endpoint) => endpoint.node) + .filter((node) => qualified ? node.qualifiedName === name : node.name === simple); + } + const unique = new Map(matches.map((node) => [node.id, node])); + return unique.size === 1 ? unique.values().next().value ?? null : null; +} + +function relationEdges(queries: QueryBuilder): Edge[] { + const edges: Edge[] = []; + for (const factNode of queries.iterateNodesByLanguageWithDecorator( + 'postgres', + POSTGRES_TABLE_RELATION_DECORATOR + )) { + const descriptor = decodePostgresTableRelationDescriptor(factNode.decorators); + if (!descriptor) continue; + const endpoints = queries + .getOutgoingEdges(factNode.id, ['references']) + .map((edge) => ({ + node: queries.getNodeById(edge.target), + refName: typeof edge.metadata?.refName === 'string' ? edge.metadata.refName : undefined, + })) + .filter((endpoint): endpoint is ResolvedEndpoint => isTable(endpoint.node)); + const source = resolvedEndpoint(endpoints, descriptor.sourceTable); + const target = resolvedEndpoint(endpoints, descriptor.targetTable); + if (!source || !target) continue; + const fact: RelationFact = { + ...descriptor, + filePath: factNode.filePath, + line: factNode.startLine, + column: factNode.startColumn, + }; + edges.push({ + source: source.id, + target: target.id, + kind: 'references', + line: factNode.startLine, + column: factNode.startColumn, + provenance: 'tree-sitter', + metadata: { + synthesizedBy: POSTGRES_STRUCTURE_SYNTHESIZER, + postgresRelation: descriptor.relation, + facts: [fact], + }, + }); + } + return edges; +} + +function isSchemaObject(node: Node): boolean { + return node.decorators?.some((decorator) => SCHEMA_OBJECT_DECORATORS.has(decorator)) === true && + node.decorators?.includes('postgres:temporary') !== true; +} + +function schemaContainmentEdges(queries: QueryBuilder): Edge[] { + const schemas = new Map(); + const nativeContainment = new Map>(); + for (const node of queries.iterateNodesByLanguage('postgres')) { + if (node.kind !== 'namespace' || node.decorators?.includes('postgres:schema') !== true) continue; + const existing = schemas.get(node.qualifiedName); + if (existing) existing.push(node); + else schemas.set(node.qualifiedName, [node]); + } + + const edges: Edge[] = []; + for (const object of queries.iterateNodesByLanguage('postgres')) { + if (!isSchemaObject(object)) continue; + const parts = parsePostgresQualifiedName(object.qualifiedName); + if (!parts || parts.length < 2 || parts[0] === 'pg_temp') continue; + const schemaName = serializePostgresQualifiedName([parts[0]!]); + const candidates = schemas.get(schemaName) ?? []; + const sameFile = candidates.filter((schema) => schema.filePath === object.filePath); + const schema = sameFile.length === 1 + ? sameFile[0] + : sameFile.length === 0 && candidates.length === 1 + ? candidates[0] + : undefined; + if (!schema) continue; + let nativeTargets = nativeContainment.get(schema.id); + if (!nativeTargets) { + nativeTargets = new Set( + queries.getOutgoingEdges(schema.id, ['contains']) + .filter((edge) => edge.metadata?.synthesizedBy !== POSTGRES_STRUCTURE_SYNTHESIZER) + .map((edge) => edge.target) + ); + nativeContainment.set(schema.id, nativeTargets); + } + if (nativeTargets.has(object.id)) continue; + edges.push({ + source: schema.id, + target: object.id, + kind: 'contains', + line: object.startLine, + column: object.startColumn, + provenance: 'tree-sitter', + metadata: { + synthesizedBy: POSTGRES_STRUCTURE_SYNTHESIZER, + postgresRelation: 'schema-containment', + }, + }); + } + return edges; +} + +function materializePostgresStructureEdges(queries: QueryBuilder): Edge[] { + return [...relationEdges(queries), ...schemaContainmentEdges(queries)]; +} + +function structureInputFingerprint( + queries: QueryBuilder +): { fingerprint: string; inputCount: number } { + const hash = createHash('sha256'); + let inputCount = 0; + let previousFact: string | null = null; + for (const row of queries.iterateDecoratorReferenceState( + 'postgres', + POSTGRES_TABLE_RELATION_DECORATOR + )) { + if (row.nodeId !== previousFact) { + inputCount++; + previousFact = row.nodeId; + } + hash.update(JSON.stringify(['fact', row])); + hash.update('\n'); + } + for (const node of queries.iterateNodesByLanguage('postgres')) { + if (node.kind !== 'namespace' && !isSchemaObject(node)) continue; + inputCount++; + hash.update(JSON.stringify([ + 'node', node.id, node.kind, node.qualifiedName, node.filePath, node.decorators, + ])); + hash.update('\n'); + if (node.kind === 'namespace') { + for (const edge of queries.getOutgoingEdges(node.id, ['contains'])) { + if (edge.metadata?.synthesizedBy === POSTGRES_STRUCTURE_SYNTHESIZER) continue; + hash.update(JSON.stringify([ + 'native-containment', edge.source, edge.target, edge.line, edge.column, + ])); + hash.update('\n'); + } + } + } + return { fingerprint: `v1:${hash.digest('hex')}`, inputCount }; +} + +function structureOutputFingerprint( + queries: QueryBuilder +): { fingerprint: string; edgeCount: number } { + const hash = createHash('sha256'); + let edgeCount = 0; + for (const edge of queries.iterateEdgesBySynthesizer(POSTGRES_STRUCTURE_SYNTHESIZER)) { + edgeCount++; + hash.update(JSON.stringify(edge)); + hash.update('\n'); + } + return { fingerprint: `v1:${hash.digest('hex')}`, edgeCount }; +} + +function persistedFingerprint(input: string, output: string): string { + return `input=${input};output=${output}`; +} + +function persistFingerprint( + queries: QueryBuilder, + input: { fingerprint: string; inputCount: number } +): void { + const output = structureOutputFingerprint(queries); + if (input.inputCount === 0 && output.edgeCount === 0) { + queries.deleteMetadata(POSTGRES_STRUCTURE_FINGERPRINT_METADATA); + } else { + queries.setMetadata( + POSTGRES_STRUCTURE_FINGERPRINT_METADATA, + persistedFingerprint(input.fingerprint, output.fingerprint) + ); + } +} + +export async function refreshPostgresStructureEdges( + queries: QueryBuilder, + onYield: MaybeYield +): Promise { + const input = structureInputFingerprint(queries); + const output = structureOutputFingerprint(queries); + const previous = queries.getMetadata(POSTGRES_STRUCTURE_FINGERPRINT_METADATA); + if (input.inputCount === 0 && output.edgeCount === 0 && previous === null) return 0; + if (previous === persistedFingerprint(input.fingerprint, output.fingerprint)) return 0; + const edges = materializePostgresStructureEdges(queries); + await onYield(); + queries.replaceEdgesBySynthesizer(POSTGRES_STRUCTURE_SYNTHESIZER, edges); + persistFingerprint(queries, input); + return edges.length; +} + +export function refreshPostgresStructureEdgesSync(queries: QueryBuilder): number { + const input = structureInputFingerprint(queries); + const output = structureOutputFingerprint(queries); + const previous = queries.getMetadata(POSTGRES_STRUCTURE_FINGERPRINT_METADATA); + if (input.inputCount === 0 && output.edgeCount === 0 && previous === null) return 0; + if (previous === persistedFingerprint(input.fingerprint, output.fingerprint)) return 0; + const edges = materializePostgresStructureEdges(queries); + queries.replaceEdgesBySynthesizer(POSTGRES_STRUCTURE_SYNTHESIZER, edges); + persistFingerprint(queries, input); + return edges.length; +} From c74844dc5be87675ec6bdf741714be24fec0430a Mon Sep 17 00:00:00 2001 From: Daniel Hritcu <134442484+dhritcu@users.noreply.github.com> Date: Sat, 1 Aug 2026 01:06:00 -0400 Subject: [PATCH 4/4] feat(postgres): model migration lifecycle and routine bodies --- CHANGELOG.md | 2 +- .../postgres-enum-rename-lifecycle.test.ts | 198 ++++ __tests__/postgres-extraction.test.ts | 225 +++- __tests__/postgres-grammar-wiring.test.ts | 127 +++ .../postgres-migration-synthesis.test.ts | 451 ++++++++ .../postgres-object-reference-intent.test.ts | 332 ++++++ __tests__/postgres-plpgsql-grammar.test.ts | 47 + .../postgres-preparse-resolution.test.ts | 68 ++ ...gres-relation-lifecycle-resolution.test.ts | 165 +++ __tests__/postgres-rename-regressions.test.ts | 163 +++ __tests__/postgres-routine-body.test.ts | 194 ++++ .../postgres-routine-search-path.test.ts | 239 ++++ package.json | 2 +- src/db/queries.ts | 13 +- src/extraction/extraction-version.ts | 2 +- src/extraction/grammars.ts | 87 +- src/extraction/languages/postgres.ts | 1015 ++++++++++++++++- src/extraction/tree-sitter-types.ts | 9 + src/extraction/tree-sitter.ts | 23 + .../wasm/tree-sitter-plpgsql.LICENSE | 25 + src/extraction/wasm/tree-sitter-plpgsql.wasm | Bin 0 -> 137462 bytes src/postgres/constraint-mutation.ts | 67 ++ src/postgres/reference-intent.ts | 29 + src/postgres/relation-lifecycle.ts | 43 + src/postgres/routine-body.ts | 674 +++++++++++ src/postgres/search-path.ts | 32 +- src/postgres/table-relation.ts | 1 + src/postgres/temporary-relations.ts | 5 +- src/postgres/type-lifecycle.ts | 81 ++ src/resolution/index.ts | 27 +- src/resolution/name-matcher.ts | 123 +- src/resolution/postgres-enum-lifecycle.ts | 239 ++++ .../postgres-foreign-key-synthesizer.ts | 252 +++- src/resolution/postgres-relation-lifecycle.ts | 119 ++ src/resolution/postgres-rename-timeline.ts | 269 +++++ .../postgres-structure-synthesizer.ts | 213 +++- src/types.ts | 15 +- 37 files changed, 5417 insertions(+), 159 deletions(-) create mode 100644 __tests__/postgres-enum-rename-lifecycle.test.ts create mode 100644 __tests__/postgres-migration-synthesis.test.ts create mode 100644 __tests__/postgres-object-reference-intent.test.ts create mode 100644 __tests__/postgres-plpgsql-grammar.test.ts create mode 100644 __tests__/postgres-preparse-resolution.test.ts create mode 100644 __tests__/postgres-relation-lifecycle-resolution.test.ts create mode 100644 __tests__/postgres-rename-regressions.test.ts create mode 100644 __tests__/postgres-routine-body.test.ts create mode 100644 __tests__/postgres-routine-search-path.test.ts create mode 100644 src/extraction/wasm/tree-sitter-plpgsql.LICENSE create mode 100644 src/extraction/wasm/tree-sitter-plpgsql.wasm create mode 100644 src/postgres/constraint-mutation.ts create mode 100644 src/postgres/reference-intent.ts create mode 100644 src/postgres/relation-lifecycle.ts create mode 100644 src/postgres/routine-body.ts create mode 100644 src/postgres/type-lifecycle.ts create mode 100644 src/resolution/postgres-enum-lifecycle.ts create mode 100644 src/resolution/postgres-relation-lifecycle.ts create mode 100644 src/resolution/postgres-rename-timeline.ts diff --git a/CHANGELOG.md b/CHANGELOG.md index 284181b5d..05bf5183a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -11,7 +11,7 @@ and adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). ### New Features -- PostgreSQL projects can now index `.sql`, `.psql`, and `.pgsql` files, including schemas, tables and columns introduced by `CREATE TABLE` or `ALTER TABLE ... ADD COLUMN`, views, routines, types, triggers, policies, indexes, sequences, extensions, and their common table, foreign-key, trigger, and routine dependencies. Altered columns are retained as relation-linked migration deltas instead of being attached to an arbitrary historical table definition; string-literal routine bodies, including dollar-quoted PL/pgSQL, remain opaque for now. +- PostgreSQL projects can now index `.sql`, `.psql`, and `.pgsql` files, including schemas, tables and altered columns, views, routines, types and enum changes, triggers, policies, indexes, sequences, extensions, and their table, foreign-key, trigger, type, sequence, and static SQL or PL/pgSQL routine-body dependencies. Migration-ordered relation drops, re-creations and renames, constraint renames, removed foreign keys, routine-local `search_path`, and malformed SQL are handled without inventing stale relationships. ## [1.5.0] - 2026-07-21 diff --git a/__tests__/postgres-enum-rename-lifecycle.test.ts b/__tests__/postgres-enum-rename-lifecycle.test.ts new file mode 100644 index 000000000..ec22dfe4a --- /dev/null +++ b/__tests__/postgres-enum-rename-lifecycle.test.ts @@ -0,0 +1,198 @@ +import { beforeAll, describe, expect, it } from 'vitest'; +import * as fs from 'node:fs'; +import * as os from 'node:os'; +import * as path from 'node:path'; +import { CodeGraph } from '../src'; +import { extractFromSource } from '../src/extraction'; +import { initGrammars, loadGrammarsForLanguages } from '../src/extraction/grammars'; +import { + decodePostgresEnumValueMutationDescriptor, + decodePostgresTypeRenameDescriptor, +} from '../src/postgres/type-lifecycle'; + +beforeAll(async () => { + await initGrammars(); + await loadGrammarsForLanguages(['postgres']); +}); + +describe('PostgreSQL enum rename lifecycle', () => { + it('encodes type identity and old/new value labels without classifying the alias early', () => { + const result = extractFromSource('db/renames.sql', [ + "CREATE TYPE app.job_status AS ENUM ('queued', 'running');", + 'ALTER TYPE app.job_status RENAME TO task_status;', + "ALTER TYPE app.task_status RENAME VALUE 'queued' TO 'pending';", + ].join('\n'), 'postgres'); + + expect(result.errors).toEqual([]); + const alias = result.nodes.find((node) => node.qualifiedName === 'app.task_status')!; + expect(alias).toMatchObject({ + kind: 'type_alias', + decorators: expect.arrayContaining(['postgres:type', 'postgres:renamed-type']), + }); + expect(alias.decorators).not.toContain('postgres:enum'); + expect(decodePostgresTypeRenameDescriptor(alias.decorators)).toEqual({ + sourceType: 'app.job_status', + targetType: 'app.task_status', + }); + + const pending = result.nodes.find((node) => node.qualifiedName === 'app.task_status.pending')!; + expect(decodePostgresEnumValueMutationDescriptor(pending.decorators)).toEqual({ + mutation: 'rename', + enumType: 'app.task_status', + sourceValue: 'queued', + targetValue: 'pending', + }); + }); + + it('carries exact effective membership through chained type and value renames', async () => { + const projectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-enum-lifecycle-')); + fs.writeFileSync( + path.join(projectDir, '001_enum.sql'), + "CREATE TYPE app.job_status AS ENUM ('queued', 'running');\n" + ); + fs.writeFileSync( + path.join(projectDir, '002_first_rename.sql'), + 'ALTER TYPE app.job_status RENAME TO task_status;\n' + ); + fs.writeFileSync( + path.join(projectDir, '003_values.sql'), + [ + "ALTER TYPE app.task_status ADD VALUE 'paused';", + "ALTER TYPE app.task_status RENAME VALUE 'queued' TO 'pending';", + ].join('\n') + '\n' + ); + fs.writeFileSync( + path.join(projectDir, '004_second_rename.sql'), + 'ALTER TYPE app.task_status RENAME TO workflow_status;\n' + ); + fs.writeFileSync( + path.join(projectDir, '005_final_values.sql'), + [ + "ALTER TYPE app.workflow_status RENAME VALUE 'running' TO 'active';", + "ALTER TYPE app.workflow_status ADD VALUE 'done';", + ].join('\n') + '\n' + ); + + const graph = CodeGraph.initSync(projectDir); + try { + await graph.indexAll(); + const original = graph.getNodesByQualifiedName('app.job_status')[0]!; + const intermediate = graph.getNodesByQualifiedName('app.task_status')[0]!; + const current = graph.getNodesByQualifiedName('app.workflow_status')[0]!; + + expect(current).toMatchObject({ + kind: 'type_alias', + decorators: expect.arrayContaining(['postgres:type', 'postgres:renamed-type']), + }); + const relationTargets = (nodeId: string) => graph.getOutgoingEdges(nodeId) + .filter((edge) => edge.metadata?.postgresRelation === 'enum-rename') + .map((edge) => edge.target); + expect(relationTargets(original.id)).toEqual([intermediate.id]); + expect(relationTargets(intermediate.id)).toEqual([current.id]); + + const effectiveMembers = (nodeId: string) => graph.getOutgoingEdges(nodeId) + .filter((edge) => edge.metadata?.postgresRelation === 'enum-effective-containment') + .map((edge) => graph.getNode(edge.target)!.name) + .sort(); + expect(effectiveMembers(intermediate.id)).toEqual(['paused', 'pending', 'running']); + expect(effectiveMembers(current.id)).toEqual(['active', 'done', 'paused', 'pending']); + expect(effectiveMembers(current.id)).not.toContain('queued'); + expect(effectiveMembers(current.id)).not.toContain('running'); + + // Historical declarations and mutation nodes remain queryable even when + // their labels are no longer part of the current enum identity. + expect(graph.getNodesByQualifiedName('app.job_status.queued')).not.toEqual([]); + expect(graph.getNodesByQualifiedName('app.task_status.pending')).not.toEqual([]); + } finally { + graph.destroy(); + fs.rmSync(projectDir, { recursive: true, force: true }); + } + }); + + it('records a native enum value rename as an explicit historical transition', async () => { + const projectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-native-enum-rename-')); + fs.writeFileSync( + path.join(projectDir, '001_enum.sql'), + "CREATE TYPE app.status AS ENUM ('pending', 'active');\n" + ); + fs.writeFileSync( + path.join(projectDir, '002_rename.sql'), + "ALTER TYPE app.status RENAME VALUE 'pending' TO 'queued';\n" + ); + + const graph = CodeGraph.initSync(projectDir); + try { + await graph.indexAll(); + const status = graph.getNodesByQualifiedName('app.status')[0]!; + const pending = graph.getNodesByQualifiedName('app.status.pending')[0]!; + const queued = graph.getNodesByQualifiedName('app.status.queued')[0]!; + const containedMembers = graph.getOutgoingEdges(status.id) + .filter((edge) => edge.kind === 'contains') + .map((edge) => graph.getNode(edge.target)!) + .filter((node) => node.kind === 'enum_member'); + + // Ordinary containment is source history: CREATE TYPE's old label stays + // queryable, and ALTER TYPE's replacement is attached by synthesis. + expect(containedMembers.map((member) => member.name).sort()).toEqual([ + 'active', + 'pending', + 'queued', + ]); + + const transition = graph.getOutgoingEdges(pending.id).find( + (edge) => edge.metadata?.postgresRelation === 'enum-value-rename' + ); + expect(transition).toMatchObject({ + target: queued.id, + kind: 'references', + metadata: { + postgresRelation: 'enum-value-rename', + enumType: 'app.status', + sourceValue: 'pending', + targetValue: 'queued', + }, + }); + + const superseded = new Set(containedMembers + .filter((member) => graph.getOutgoingEdges(member.id).some( + (edge) => edge.metadata?.postgresRelation === 'enum-value-rename' + )) + .map((member) => member.id)); + expect(containedMembers + .filter((member) => !superseded.has(member.id)) + .map((member) => member.name) + .sort()).toEqual(['active', 'queued']); + } finally { + graph.destroy(); + fs.rmSync(projectDir, { recursive: true, force: true }); + } + }); + + it('does not infer enum identity for a renamed composite type', async () => { + const projectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-type-lifecycle-')); + fs.writeFileSync( + path.join(projectDir, '001_type.sql'), + 'CREATE TYPE app.point AS (x integer, y integer);\n' + ); + fs.writeFileSync( + path.join(projectDir, '002_rename.sql'), + 'ALTER TYPE app.point RENAME TO coordinate;\n' + ); + + const graph = CodeGraph.initSync(projectDir); + try { + await graph.indexAll(); + const alias = graph.getNodesByQualifiedName('app.coordinate')[0]!; + expect(alias.kind).toBe('type_alias'); + expect(graph.getIncomingEdges(alias.id).some( + (edge) => edge.metadata?.postgresRelation === 'enum-rename' + )).toBe(false); + expect(graph.getOutgoingEdges(alias.id).some( + (edge) => edge.metadata?.postgresRelation === 'enum-effective-containment' + )).toBe(false); + } finally { + graph.destroy(); + fs.rmSync(projectDir, { recursive: true, force: true }); + } + }); +}); diff --git a/__tests__/postgres-extraction.test.ts b/__tests__/postgres-extraction.test.ts index a2d680748..6878a2ba9 100644 --- a/__tests__/postgres-extraction.test.ts +++ b/__tests__/postgres-extraction.test.ts @@ -9,10 +9,24 @@ import { POSTGRES_FOREIGN_KEY_DECORATOR, decodePostgresForeignKeyDescriptor, } from '../src/postgres/foreign-key'; +import { + POSTGRES_DROP_CONSTRAINT_DECORATOR, + POSTGRES_RENAME_CONSTRAINT_DECORATOR, + decodePostgresDropConstraintDescriptor, + decodePostgresRenameConstraintDescriptor, +} from '../src/postgres/constraint-mutation'; import { POSTGRES_TABLE_RELATION_DECORATOR, decodePostgresTableRelationDescriptor, } from '../src/postgres/table-relation'; +import { + POSTGRES_SEQUENCE_REFERENCE_KIND, + POSTGRES_TYPE_REFERENCE_KIND, +} from '../src/postgres/reference-intent'; +import { + POSTGRES_DROP_RELATION_DECORATOR, + decodePostgresDropRelationDescriptor, +} from '../src/postgres/relation-lifecycle'; beforeAll(async () => { await initGrammars(); @@ -24,6 +38,17 @@ function extract(source: string) { } describe('PostgreSQL extraction', () => { + it('reports recovered syntax errors instead of silently marking the file clean', () => { + const result = extract('CREATE TABLE broken (id bigint,,);'); + expect(result.errors).toEqual([ + expect.objectContaining({ + code: 'parse_error', + filePath: 'db/schema.sql', + severity: 'error', + }), + ]); + }); + it('extracts database objects and columns with generic CodeGraph kinds', () => { const result = extract([ 'CREATE SCHEMA app;', @@ -85,6 +110,43 @@ describe('PostgreSQL extraction', () => { ])); }); + it('does not treat PostgreSQL range and multirange catalog types as user-defined', () => { + const result = extract([ + 'CREATE TABLE app.availability (', + ' dates daterange, date_sets datemultirange,', + ' integers int4range, integer_sets int4multirange,', + ' bigints int8range, bigint_sets int8multirange,', + ' numbers numrange, number_sets nummultirange,', + ' timestamps tsrange, timestamp_sets tsmultirange,', + ' zoned_times tstzrange, zoned_time_sets tstzmultirange', + ');', + ].join('\n')); + + expect(result.errors).toEqual([]); + expect(result.unresolvedReferences.filter( + (ref) => ref.referenceKind === POSTGRES_TYPE_REFERENCE_KIND + )).toEqual([]); + }); + + it('emits sequence references only for literal first arguments through casts', () => { + const result = extract([ + 'CREATE TABLE app.events (', + " literal_id bigint DEFAULT nextval((('app.literal_seq'))::regclass),", + " cast_id bigint DEFAULT setval(CAST('app.cast_seq' AS regclass), 1),", + " current_id bigint DEFAULT currval('app.current_seq'::regclass),", + " concatenated_id bigint DEFAULT nextval(('app.foo_' || tenant)::regclass),", + " formatted_id bigint DEFAULT nextval(format('app.%s_seq', tenant)::regclass)", + ');', + ].join('\n')); + + expect(result.errors).toEqual([]); + expect(result.unresolvedReferences + .filter((ref) => ref.referenceKind === POSTGRES_SEQUENCE_REFERENCE_KIND) + .map((ref) => ref.referenceName) + .sort() + ).toEqual(['app.cast_seq', 'app.current_seq', 'app.literal_seq']); + }); + it('emits and de-duplicates relation and routine references while ignoring CTE aliases', () => { const result = extract([ 'CREATE VIEW app.dashboard AS', @@ -454,7 +516,147 @@ describe('PostgreSQL extraction', () => { } }); - it('keeps dollar-quoted PL/pgSQL bodies opaque in the PostgreSQL-only phase', () => { + it('indexes renames, ALTER policy/enum/sequence state, and non-FK constraints', () => { + const result = extract([ + 'SET search_path = public;', + "CREATE TYPE lease_status AS ENUM ('draft');", + "ALTER TYPE lease_status ADD VALUE 'pending_signature' BEFORE 'completed';", + "CREATE TABLE submission_tags (id bigint, label text, status lease_status, sequence_id bigint DEFAULT nextval('daily_application_counts_id_seq'::regclass),", + ' CONSTRAINT submission_tags_pkey PRIMARY KEY (id),', + ' CONSTRAINT submission_tags_label_key UNIQUE (label),', + ' CONSTRAINT submission_tags_label_check CHECK (length(label) > 0));', + 'ALTER TABLE submission_tags RENAME TO tags;', + 'ALTER TABLE tags RENAME COLUMN label TO title;', + 'ALTER TABLE tags ALTER COLUMN status SET DATA TYPE lease_status USING status::text::lease_status;', + 'CREATE POLICY tags_read ON tags USING (true);', + 'ALTER POLICY tags_read ON tags USING (EXISTS (SELECT 1 FROM organizations));', + 'ALTER POLICY tags_read ON tags RENAME TO tags_select;', + 'CREATE SEQUENCE daily_application_counts_id_seq;', + 'ALTER SEQUENCE daily_application_counts_id_seq OWNED BY tags.id;', + 'ALTER TABLE tags ALTER COLUMN id ADD GENERATED BY DEFAULT AS IDENTITY', + ' (SEQUENCE NAME tags_id_seq);', + 'ALTER TABLE tags RENAME CONSTRAINT submission_tags_label_key TO tags_title_key;', + 'ALTER TABLE tags DROP CONSTRAINT submission_tags_pkey;', + ].join('\n')); + + expect(result.errors).toEqual([]); + const byQualifiedName = new Map(result.nodes.map((node) => [node.qualifiedName, node])); + expect(byQualifiedName.get('public.tags')?.decorators).toEqual(expect.arrayContaining([ + 'postgres:table', + 'postgres:renamed-relation', + ])); + expect(byQualifiedName.get('public.tags.title')?.decorators).toEqual(expect.arrayContaining([ + 'postgres:column', + 'postgres:renamed-column', + ])); + expect(byQualifiedName.get('public.lease_status.pending_signature')?.decorators).toEqual( + expect.arrayContaining(['postgres:enum-value', 'postgres:alter-enum-add-value']) + ); + expect(byQualifiedName.get('public.tags.tags_select')?.decorators).toEqual( + expect.arrayContaining(['postgres:policy', 'postgres:renamed-policy']) + ); + expect(result.nodes.find((node) => + node.qualifiedName === 'public.tags.tags_read' && + node.decorators?.includes('postgres:alter-policy') + )).toBeTruthy(); + expect(result.nodes.filter((node) => node.decorators?.includes('postgres:constraint'))) + .toEqual(expect.arrayContaining([ + expect.objectContaining({ name: 'submission_tags_pkey' }), + expect.objectContaining({ name: 'submission_tags_label_key' }), + expect.objectContaining({ name: 'submission_tags_label_check' }), + ])); + expect(byQualifiedName.get('public.tags_id_seq')?.decorators).toEqual( + expect.arrayContaining(['postgres:sequence', 'postgres:identity-sequence']) + ); + expect(result.nodes.find((node) => + node.name === 'daily_application_counts_id_seq' && + node.decorators?.includes('postgres:sequence-ownership') + )).toBeTruthy(); + + const statusField = byQualifiedName.get('public.submission_tags.status')!; + expect(result.unresolvedReferences).toEqual(expect.arrayContaining([ + expect.objectContaining({ + fromNodeId: statusField.id, + referenceKind: POSTGRES_TYPE_REFERENCE_KIND, + referenceName: 'lease_status', + }), + expect.objectContaining({ + fromNodeId: byQualifiedName.get('public.submission_tags.sequence_id')!.id, + referenceKind: POSTGRES_SEQUENCE_REFERENCE_KIND, + referenceName: 'daily_application_counts_id_seq', + }), + ])); + const typeDelta = result.nodes.find((node) => + node.decorators?.includes('postgres:alter-table-column-type') + )!; + expect(result.unresolvedReferences.some((ref) => + ref.fromNodeId === typeDelta.id && + ref.referenceKind === POSTGRES_TYPE_REFERENCE_KIND && + ref.referenceName === 'lease_status' + )).toBe(true); + const sequenceOwnership = result.nodes.find((node) => + node.decorators?.includes('postgres:sequence-ownership') + )!; + expect(result.unresolvedReferences.some((ref) => + ref.fromNodeId === sequenceOwnership.id && + ref.referenceKind === POSTGRES_SEQUENCE_REFERENCE_KIND && + ref.referenceName === 'public.daily_application_counts_id_seq' + )).toBe(true); + + const alteredPolicy = result.nodes.find((node) => + node.decorators?.includes('postgres:alter-policy') + )!; + expect(result.unresolvedReferences + .filter((ref) => ref.fromNodeId === alteredPolicy.id) + .map((ref) => ref.referenceName) + .sort() + ).toEqual(['organizations', 'tags']); + + const drop = result.nodes.find((node) => + node.decorators?.includes(POSTGRES_DROP_CONSTRAINT_DECORATOR) + )!; + expect(decodePostgresDropConstraintDescriptor(drop.decorators)).toEqual({ + table: 'public.tags', + constraintName: 'submission_tags_pkey', + }); + + const rename = result.nodes.find((node) => + node.decorators?.includes(POSTGRES_RENAME_CONSTRAINT_DECORATOR) + )!; + expect(decodePostgresRenameConstraintDescriptor(rename.decorators)).toEqual({ + table: 'public.tags', + sourceConstraint: 'submission_tags_label_key', + targetConstraint: 'tags_title_key', + }); + }); + + it('records ordered table and view drops as relation lifecycle facts', () => { + const result = extract([ + 'SET search_path = app;', + 'DROP TABLE IF EXISTS users, audit.events CASCADE;', + 'DROP MATERIALIZED VIEW IF EXISTS user_rollup;', + ].join('\n')); + + expect(result.errors).toEqual([]); + const drops = result.nodes.filter((node) => + node.decorators?.includes(POSTGRES_DROP_RELATION_DECORATOR) + ); + expect(drops.map((node) => decodePostgresDropRelationDescriptor(node.decorators))) + .toEqual(expect.arrayContaining([ + { relationName: 'app.users', relationKind: 'table' }, + { relationName: 'audit.events', relationKind: 'table' }, + { relationName: 'app.user_rollup', relationKind: 'materialized-view' }, + ])); + expect(result.unresolvedReferences.filter((ref) => + drops.some((drop) => drop.id === ref.fromNodeId) + ).map((ref) => ref.referenceName).sort()).toEqual([ + 'app.user_rollup', + 'app.users', + 'audit.events', + ]); + }); + + it('indexes static SQL regions inside PL/pgSQL routines and DO blocks', () => { const result = extract([ 'CREATE FUNCTION app.run_job() RETURNS void', 'LANGUAGE plpgsql AS $$', @@ -463,11 +665,26 @@ describe('PostgreSQL extraction', () => { ' INSERT INTO app.hidden_table VALUES (1);', 'END', '$$;', + 'DO $$', + 'BEGIN', + ' UPDATE app.job_state SET complete = true;', + 'END', + '$$;', ].join('\n')); - expect(result.nodes.some((node) => node.qualifiedName === 'app.run_job')).toBe(true); - expect(result.unresolvedReferences.some((ref) => ref.referenceName === 'app.hidden_call')).toBe(false); - expect(result.unresolvedReferences.some((ref) => ref.referenceName === 'app.hidden_table')).toBe(false); + const routine = result.nodes.find((node) => node.qualifiedName === 'app.run_job')!; + const doBlock = result.nodes.find((node) => node.decorators?.includes('postgres:do-block'))!; + expect(routine).toBeTruthy(); + expect(doBlock).toBeTruthy(); + expect(result.unresolvedReferences + .filter((ref) => ref.fromNodeId === routine.id) + .map((ref) => `${ref.referenceKind}:${ref.referenceName}`) + .sort() + ).toEqual(['calls:app.hidden_call', 'references:app.hidden_table']); + expect(result.unresolvedReferences + .filter((ref) => ref.fromNodeId === doBlock.id) + .map((ref) => `${ref.referenceKind}:${ref.referenceName}`) + ).toEqual(['references:app.job_state']); }); it('indexes and resolves PostgreSQL dependencies through the full CodeGraph pipeline', async () => { diff --git a/__tests__/postgres-grammar-wiring.test.ts b/__tests__/postgres-grammar-wiring.test.ts index 5c43440aa..b284e4ac7 100644 --- a/__tests__/postgres-grammar-wiring.test.ts +++ b/__tests__/postgres-grammar-wiring.test.ts @@ -10,6 +10,7 @@ import { loadGrammarsForLanguages, readGrammarWasmBytes, } from '../src/extraction/grammars'; +import { preParsePostgresSource } from '../src/extraction/languages/postgres'; describe('PostgreSQL grammar wiring', () => { beforeAll(async () => { @@ -45,4 +46,130 @@ describe('PostgreSQL grammar wiring', () => { expect(tree!.rootNode.hasError).toBe(false); tree!.delete(); }); + + it('prepares psql variables, COPY payloads, and valid CHECK comparisons without shifting offsets', () => { + const source = [ + "\\set winner_id 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'", + "SELECT public.merge_user(:'winner_id'::uuid);", + 'CREATE TABLE audit.events (', + ' op text,', + ' record jsonb,', + " CHECK (op IN ('INSERT', 'UPDATE') = (record IS NOT NULL))", + ');', + 'COPY audit.events (op, record) FROM STDIN;', + 'INSERT\t{"id": 1}', + '\\.', + 'SELECT * FROM audit.events;', + ].join('\n'); + const prepared = preParsePostgresSource(source); + expect(prepared.length).toBe(source.length); + expect([...prepared.matchAll(/\n/g)].map((match) => match.index)) + .toEqual([...source.matchAll(/\n/g)].map((match) => match.index)); + expect(prepared.split('\n')[0]).toMatch(/^\s+$/); + expect(prepared.split('\n')[8]).toMatch(/^\s+$/); + expect(prepared.split('\n')[9]).toMatch(/^\s+$/); + + const unicode = "-- 😀\n\\set value 'x'\nSELECT :value::text;"; + const preparedUnicode = preParsePostgresSource(unicode); + expect(preparedUnicode.length).toBe(unicode.length); + expect(preparedUnicode).toMatch(/SELECT \$1\s+::text;/); + + const parser = getParser('postgres')!; + const tree = parser.parse(prepared); + expect(tree!.rootNode.hasError).toBe(false); + tree!.delete(); + }); + + it('limits COPY payload masking to real server and psql COPY commands', () => { + const psqlCopy = [ + '\\copy audit.events FROM STDIN', + 'INSERT\t{"id": 1};', + '\\.', + 'SELECT * FROM audit.events;', + ].join('\n'); + const preparedPsqlCopy = preParsePostgresSource(psqlCopy); + expect(preparedPsqlCopy.split('\n').slice(0, 3)).toEqual([ + expect.stringMatching(/^\s+$/), + expect.stringMatching(/^\s+$/), + expect.stringMatching(/^\s+$/), + ]); + expect(preparedPsqlCopy.split('\n')[3]).toBe('SELECT * FROM audit.events;'); + + const psqlQueryCopy = [ + '\\copy (SELECT copy FROM stdin) TO STDOUT', + 'SELECT * FROM users;', + ].join('\n'); + expect(preParsePostgresSource(psqlQueryCopy).split('\n')[1]) + .toBe('SELECT * FROM users;'); + + const identifierUse = 'SELECT copy FROM stdin;\nSELECT * FROM users;'; + expect(preParsePostgresSource(identifierUse)).toBe(identifierUse); + + const protocolOnly = 'COPY audit.events FROM STDIN;\nSELECT * FROM users;'; + expect(preParsePostgresSource(protocolOnly)).toBe(protocolOnly); + + const csvCopy = [ + 'COPY audit.events FROM STDIN WITH (FORMAT csv);', + 'INSERT,{"id": 1}', + '\\.', + 'SELECT * FROM audit.events;', + ].join('\n'); + const preparedCsvCopy = preParsePostgresSource(csvCopy); + expect(preparedCsvCopy.split('\n')[1]).toMatch(/^\s+$/); + expect(preparedCsvCopy.split('\n')[2]).toMatch(/^\s+$/); + expect(preparedCsvCopy.split('\n')[3]).toBe('SELECT * FROM audit.events;'); + + const queryCopy = 'COPY (SELECT copy FROM stdin) TO STDOUT;\nSELECT * FROM users;'; + expect(preParsePostgresSource(queryCopy)).toBe(queryCopy); + + const parser = getParser('postgres')!; + for (const prepared of [ + preparedPsqlCopy, + identifierUse, + protocolOnly, + preparedCsvCopy, + queryCopy, + ]) { + const tree = parser.parse(prepared); + expect(tree.rootNode.hasError).toBe(false); + tree.delete(); + } + }); + + it('uses backslash escapes only in E/e strings while locating COPY payloads', () => { + const sources = [ + // With standard_conforming_strings, the backslash is data and the quote + // immediately after it terminates the ordinary string. + String.raw`SELECT 'x\';`, + // In an escape string, the first quote is escaped and the second closes + // the literal. Exercise both accepted prefix spellings. + String.raw`SELECT E'x\'';`, + String.raw`SELECT e'x\'';`, + ]; + + for (const firstStatement of sources) { + const source = [ + firstStatement, + String.raw`\copy audit.psql_events FROM STDIN`, + '1\tpsql payload', + String.raw`\.`, + 'COPY audit.server_events FROM STDIN;', + '2\tserver payload', + String.raw`\.`, + 'SELECT * FROM audit.server_events;', + ].join('\n'); + const prepared = preParsePostgresSource(source); + const lines = prepared.split('\n'); + + expect(prepared.length).toBe(source.length); + expect(lines[0]).toBe(firstStatement); + expect(lines[1]).toMatch(/^\s+$/); + expect(lines[2]).toMatch(/^\s+$/); + expect(lines[3]).toMatch(/^\s+$/); + expect(lines[4]).toBe('COPY audit.server_events FROM STDIN;'); + expect(lines[5]).toMatch(/^\s+$/); + expect(lines[6]).toMatch(/^\s+$/); + expect(lines[7]).toBe('SELECT * FROM audit.server_events;'); + } + }); }); diff --git a/__tests__/postgres-migration-synthesis.test.ts b/__tests__/postgres-migration-synthesis.test.ts new file mode 100644 index 000000000..b8dc898c2 --- /dev/null +++ b/__tests__/postgres-migration-synthesis.test.ts @@ -0,0 +1,451 @@ +import { afterEach, beforeEach, describe, expect, it } from 'vitest'; +import * as fs from 'node:fs'; +import * as os from 'node:os'; +import * as path from 'node:path'; +import { DatabaseConnection } from '../src/db'; +import { QueryBuilder } from '../src/db/queries'; +import { + POSTGRES_DROP_CONSTRAINT_DECORATOR, + POSTGRES_RENAME_CONSTRAINT_DECORATOR, + encodePostgresDropConstraintDescriptor, + encodePostgresRenameConstraintDescriptor, +} from '../src/postgres/constraint-mutation'; +import { + POSTGRES_FOREIGN_KEY_DECORATOR, + encodePostgresForeignKeyDescriptor, +} from '../src/postgres/foreign-key'; +import { + POSTGRES_DROP_RELATION_DECORATOR, + encodePostgresDropRelationDescriptor, +} from '../src/postgres/relation-lifecycle'; +import { + POSTGRES_TABLE_RELATION_DECORATOR, + encodePostgresTableRelationDescriptor, + type PostgresTableRelationKind, +} from '../src/postgres/table-relation'; +import { + POSTGRES_FOREIGN_KEY_SYNTHESIZER, + refreshPostgresForeignKeyEdgesSync, +} from '../src/resolution/postgres-foreign-key-synthesizer'; +import { + POSTGRES_STRUCTURE_SYNTHESIZER, + refreshPostgresStructureEdgesSync, +} from '../src/resolution/postgres-structure-synthesizer'; +import type { Edge, Node, NodeKind } from '../src/types'; + +function makeNode( + id: string, + qualifiedName: string, + filePath: string, + line: number, + kind: NodeKind, + decorators: string[], + column = 0 +): Node { + return { + id, + kind, + name: qualifiedName.split('.').at(-1) ?? qualifiedName, + qualifiedName, + filePath, + language: 'postgres', + startLine: line, + endLine: line, + startColumn: column, + endColumn: column, + decorators, + updatedAt: Date.now(), + }; +} + +function table(id: string, name: string, filePath: string, line = 1): Node { + return makeNode(id, name, filePath, line, 'struct', ['postgres:table']); +} + +describe('PostgreSQL ordered migration synthesis', () => { + let dir: string; + let db: DatabaseConnection; + let queries: QueryBuilder; + + beforeEach(() => { + dir = fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-postgres-migrations-')); + db = DatabaseConnection.initialize(path.join(dir, 'codegraph.db')); + queries = new QueryBuilder(db.getDb()); + }); + + afterEach(() => { + db.close(); + fs.rmSync(dir, { recursive: true, force: true }); + }); + + function insertReference(fact: Node, target: Node, refName: string): void { + queries.insertEdge({ + source: fact.id, + target: target.id, + kind: 'references', + line: fact.startLine, + column: fact.startColumn, + provenance: 'tree-sitter', + metadata: { refName }, + }); + } + + function insertRelationFact( + id: string, + relation: PostgresTableRelationKind, + source: string, + target: string, + filePath: string, + line: number, + endpoints: Array<[Node, string]>, + column = 0 + ): Node { + const fact = makeNode(id, id, filePath, line, 'constant', [ + POSTGRES_TABLE_RELATION_DECORATOR, + encodePostgresTableRelationDescriptor({ + relation, + sourceTable: source, + targetTable: target, + }), + ], column); + queries.insertNode(fact); + for (const [endpoint, refName] of endpoints) insertReference(fact, endpoint, refName); + return fact; + } + + function insertForeignKeyFact( + id: string, + source: Node, + target: Node, + sourceName: string, + targetName: string, + constraintName: string, + filePath: string, + line: number + ): Node { + const fact = makeNode(id, id, filePath, line, 'constant', [ + POSTGRES_FOREIGN_KEY_DECORATOR, + encodePostgresForeignKeyDescriptor({ + sourceTable: sourceName, + targetTable: targetName, + constraintName, + sourceColumns: ['target_id'], + targetColumns: ['id'], + }), + ]); + queries.insertNode(fact); + insertReference(fact, source, sourceName); + insertReference(fact, target, targetName); + return fact; + } + + function insertConstraintRename( + id: string, + tableName: string, + sourceConstraint: string, + targetConstraint: string, + filePath: string, + line: number + ): Node { + const fact = makeNode(id, id, filePath, line, 'constant', [ + POSTGRES_RENAME_CONSTRAINT_DECORATOR, + encodePostgresRenameConstraintDescriptor({ + table: tableName, + sourceConstraint, + targetConstraint, + }), + ]); + queries.insertNode(fact); + return fact; + } + + function synthesizedEdges(source: Node, synthesizer: string): Edge[] { + return queries.getOutgoingEdges(source.id).filter( + (edge) => edge.metadata?.synthesizedBy === synthesizer + ); + } + + it('retains immediate rename edges and projects only older structural facts to the final alias', () => { + const oldTable = table('table:old', 'public.submission_tags', '000_schema.sql'); + const middleTable = table('table:middle', 'public.tags', '002_rename.sql'); + const finalTable = table('table:final', 'public.labels', '003_rename.sql'); + const before = table('table:before', 'public.before_relation', '001_relations.sql'); + const after = table('table:after', 'public.after_relation', '004_relations.sql'); + for (const node of [oldTable, middleTable, finalTable, before, after]) { + queries.insertNode(node); + } + + insertRelationFact( + 'fact:before', 'like', before.qualifiedName, oldTable.qualifiedName, + '001_relations.sql', 10, + [[before, before.qualifiedName], [oldTable, oldTable.qualifiedName]] + ); + // Deliberately resolve only the old endpoint. The target aliases must come + // from the unique exact qualified-name index, not a fuzzy name lookup. + insertRelationFact( + 'fact:rename-middle', 'rename', oldTable.qualifiedName, middleTable.qualifiedName, + '002_rename.sql', 1, [[oldTable, oldTable.qualifiedName]] + ); + insertRelationFact( + 'fact:rename-final', 'rename', middleTable.qualifiedName, finalTable.qualifiedName, + '003_rename.sql', 1, [[middleTable, middleTable.qualifiedName]] + ); + insertRelationFact( + 'fact:after', 'inherits', after.qualifiedName, oldTable.qualifiedName, + '004_relations.sql', 1, + [[after, after.qualifiedName], [oldTable, oldTable.qualifiedName]] + ); + + refreshPostgresStructureEdgesSync(queries); + + expect(synthesizedEdges(oldTable, POSTGRES_STRUCTURE_SYNTHESIZER)).toEqual( + expect.arrayContaining([ + expect.objectContaining({ + target: middleTable.id, + metadata: expect.objectContaining({ postgresRelation: 'rename' }), + }), + ]) + ); + expect(synthesizedEdges(middleTable, POSTGRES_STRUCTURE_SYNTHESIZER)).toEqual( + expect.arrayContaining([ + expect.objectContaining({ + target: finalTable.id, + metadata: expect.objectContaining({ postgresRelation: 'rename' }), + }), + ]) + ); + expect(synthesizedEdges(before, POSTGRES_STRUCTURE_SYNTHESIZER)).toEqual( + expect.arrayContaining([ + expect.objectContaining({ + target: finalTable.id, + metadata: expect.objectContaining({ postgresRelation: 'like' }), + }), + ]) + ); + // Earlier rename events are not applied retroactively to later facts. + expect(synthesizedEdges(after, POSTGRES_STRUCTURE_SYNTHESIZER)).toEqual( + expect.arrayContaining([ + expect.objectContaining({ + target: oldTable.id, + metadata: expect.objectContaining({ postgresRelation: 'inherits' }), + }), + ]) + ); + }); + + it('does not guess a rename target when the exact qualified name is ambiguous', () => { + const oldTable = table('table:old', 'public.old_name', '001_schema.sql'); + const aliasOne = table('table:new-1', 'public.new_name', '002_rename.sql'); + const aliasTwo = table('table:new-2', 'public.new_name', '009_duplicate.sql'); + for (const node of [oldTable, aliasOne, aliasTwo]) queries.insertNode(node); + insertRelationFact( + 'fact:rename', 'rename', oldTable.qualifiedName, aliasOne.qualifiedName, + '002_rename.sql', 1, [[oldTable, oldTable.qualifiedName]] + ); + + refreshPostgresStructureEdgesSync(queries); + expect(synthesizedEdges(oldTable, POSTGRES_STRUCTURE_SYNTHESIZER)).toEqual([]); + }); + + it('does not infer migration chronology across independent SQL directories', () => { + const oldTable = table('table:old', 'public.old_name', 'schema/001_tables.sql'); + const alias = table('table:new', 'public.new_name', 'migrations/002_rename.sql'); + const dependent = table('table:dependent', 'public.dependent', 'schema/001_tables.sql'); + for (const node of [oldTable, alias, dependent]) queries.insertNode(node); + insertRelationFact( + 'fact:before', 'like', dependent.qualifiedName, oldTable.qualifiedName, + 'schema/001_tables.sql', 2, + [[dependent, dependent.qualifiedName], [oldTable, oldTable.qualifiedName]] + ); + insertRelationFact( + 'fact:rename', 'rename', oldTable.qualifiedName, alias.qualifiedName, + 'migrations/002_rename.sql', 1, + [[oldTable, oldTable.qualifiedName], [alias, alias.qualifiedName]] + ); + + refreshPostgresStructureEdgesSync(queries); + expect(synthesizedEdges(dependent, POSTGRES_STRUCTURE_SYNTHESIZER)).toEqual([ + expect.objectContaining({ + target: oldTable.id, + metadata: expect.objectContaining({ postgresRelation: 'like' }), + }), + ]); + }); + + it('reprojects FKs after renames and suppresses only facts preceding a named drop', () => { + const oldOrders = table('table:orders', 'public.orders', '000_schema.sql'); + const newOrders = table('table:purchases', 'public.purchases', '002_renames.sql'); + const oldTags = table('table:tags-old', 'public.submission_tags', '000_schema.sql'); + const newTags = table('table:tags-new', 'public.tags', '002_renames.sql'); + for (const node of [oldOrders, newOrders, oldTags, newTags]) queries.insertNode(node); + + insertForeignKeyFact( + 'fk:keep', oldOrders, oldTags, + oldOrders.qualifiedName, oldTags.qualifiedName, + 'orders_keep_fk', '001_constraints.sql', 1 + ); + insertForeignKeyFact( + 'fk:drop-old', oldOrders, oldTags, + oldOrders.qualifiedName, oldTags.qualifiedName, + 'orders_drop_fk', '001_constraints.sql', 2 + ); + + refreshPostgresForeignKeyEdgesSync(queries); + expect(synthesizedEdges(oldOrders, POSTGRES_FOREIGN_KEY_SYNTHESIZER)).toHaveLength(1); + + insertRelationFact( + 'rename:orders', 'rename', oldOrders.qualifiedName, newOrders.qualifiedName, + '002_renames.sql', 1, [[oldOrders, oldOrders.qualifiedName]] + ); + insertRelationFact( + 'rename:tags', 'rename', oldTags.qualifiedName, newTags.qualifiedName, + '002_renames.sql', 2, [[oldTags, oldTags.qualifiedName]] + ); + insertConstraintRename( + 'rename:keep-fk', newOrders.qualifiedName, + 'orders_keep_fk', 'purchases_keep_fk', '002a_constraint_renames.sql', 1 + ); + insertConstraintRename( + 'rename:drop-fk', newOrders.qualifiedName, + 'orders_drop_fk', 'purchases_drop_fk', '002a_constraint_renames.sql', 2 + ); + + refreshPostgresForeignKeyEdgesSync(queries); + expect(synthesizedEdges(oldOrders, POSTGRES_FOREIGN_KEY_SYNTHESIZER)).toEqual([]); + let projected = synthesizedEdges(newOrders, POSTGRES_FOREIGN_KEY_SYNTHESIZER); + expect(projected).toEqual([ + expect.objectContaining({ target: newTags.id }), + ]); + expect((projected[0]!.metadata?.constraints as Array<{ constraintName: string }>)) + .toEqual(expect.arrayContaining([ + expect.objectContaining({ + constraintName: 'purchases_keep_fk', + originalConstraintName: 'orders_keep_fk', + }), + expect.objectContaining({ + constraintName: 'purchases_drop_fk', + originalConstraintName: 'orders_drop_fk', + }), + ])); + + const drop = makeNode('drop:orders-fk', 'drop:orders-fk', '003_drop.sql', 1, 'constant', [ + POSTGRES_DROP_CONSTRAINT_DECORATOR, + encodePostgresDropConstraintDescriptor({ + table: newOrders.qualifiedName, + constraintName: 'purchases_drop_fk', + }), + ]); + queries.insertNode(drop); + refreshPostgresForeignKeyEdgesSync(queries); + projected = synthesizedEdges(newOrders, POSTGRES_FOREIGN_KEY_SYNTHESIZER); + expect((projected[0]!.metadata?.constraints as Array<{ constraintName: string }>)) + .toEqual([expect.objectContaining({ constraintName: 'purchases_keep_fk' })]); + + // Re-adding the same named constraint after the drop is a new live fact. + insertForeignKeyFact( + 'fk:drop-readded', newOrders, newTags, + newOrders.qualifiedName, newTags.qualifiedName, + 'purchases_drop_fk', '004_readd.sql', 1 + ); + refreshPostgresForeignKeyEdgesSync(queries); + projected = synthesizedEdges(newOrders, POSTGRES_FOREIGN_KEY_SYNTHESIZER); + expect((projected[0]!.metadata?.constraints as Array<{ constraintName: string }>)) + .toEqual(expect.arrayContaining([ + expect.objectContaining({ constraintName: 'purchases_keep_fk' }), + expect.objectContaining({ constraintName: 'purchases_drop_fk', filePath: '004_readd.sql' }), + ])); + expect((projected[0]!.metadata?.constraints as Array<{ filePath: string }>).some( + (constraint) => constraint.filePath === '001_constraints.sql' && + (constraint as { constraintName?: string }).constraintName === 'purchases_drop_fk' + )).toBe(false); + }); + + it('suppresses an old table FK after DROP but keeps a constraint added after recreation', () => { + const users = table('table:users', 'public.users', '000_schema.sql'); + const oldOrders = table('table:orders:v1', 'public.orders', '000_schema.sql'); + queries.insertNode(users); + queries.insertNode(oldOrders); + insertForeignKeyFact( + 'fk:orders:v1', oldOrders, users, + oldOrders.qualifiedName, users.qualifiedName, + 'orders_user_fk', '001_constraints.sql', 1 + ); + + const drop = makeNode('drop:orders', 'drop:orders', '002_drop.sql', 1, 'constant', [ + POSTGRES_DROP_RELATION_DECORATOR, + encodePostgresDropRelationDescriptor({ + relationName: oldOrders.qualifiedName, + relationKind: 'table', + }), + ]); + queries.insertNode(drop); + refreshPostgresForeignKeyEdgesSync(queries); + expect(synthesizedEdges(oldOrders, POSTGRES_FOREIGN_KEY_SYNTHESIZER)).toEqual([]); + + const newOrders = table('table:orders:v2', 'public.orders', '003_recreate.sql'); + queries.insertNode(newOrders); + insertForeignKeyFact( + 'fk:orders:v2', newOrders, users, + newOrders.qualifiedName, users.qualifiedName, + 'orders_owner_fk', '004_constraints.sql', 1 + ); + refreshPostgresForeignKeyEdgesSync(queries); + expect(synthesizedEdges(oldOrders, POSTGRES_FOREIGN_KEY_SYNTHESIZER)).toEqual([]); + expect(synthesizedEdges(newOrders, POSTGRES_FOREIGN_KEY_SYNTHESIZER)).toEqual([ + expect.objectContaining({ target: users.id }), + ]); + }); + + it('adds exact enum-member containment without duplicating native edges', () => { + const enumNode = makeNode( + 'enum:status', 'public.status', '001_schema.sql', 1, 'enum', ['postgres:enum'] + ); + const nativeMember = makeNode( + 'enum:status:open', 'public.status.open', '001_schema.sql', 1, + 'enum_member', ['postgres:enum-value'] + ); + const alteredMember = makeNode( + 'enum:status:closed', 'public.status.closed', '002_alter.sql', 1, + 'enum_member', ['postgres:enum-value'] + ); + for (const node of [enumNode, nativeMember, alteredMember]) queries.insertNode(node); + queries.insertEdge({ + source: enumNode.id, + target: nativeMember.id, + kind: 'contains', + line: 1, + column: 0, + provenance: 'tree-sitter', + }); + + refreshPostgresStructureEdgesSync(queries); + let contained = queries.getOutgoingEdges(enumNode.id, ['contains']); + expect(contained.filter((edge) => edge.target === nativeMember.id)).toHaveLength(1); + expect(contained.filter((edge) => edge.target === alteredMember.id)).toEqual([ + expect.objectContaining({ + metadata: expect.objectContaining({ + synthesizedBy: POSTGRES_STRUCTURE_SYNTHESIZER, + postgresRelation: 'enum-containment', + }), + }), + ]); + + const recreatedEnum = makeNode( + 'enum:status:v2', 'public.status', '003_recreate.sql', 1, + 'enum', ['postgres:enum'] + ); + const laterMember = makeNode( + 'enum:status:archived', 'public.status.archived', '004_alter.sql', 1, + 'enum_member', ['postgres:enum-value'] + ); + queries.insertNode(recreatedEnum); + queries.insertNode(laterMember); + refreshPostgresStructureEdgesSync(queries); + contained = queries.getOutgoingEdges(enumNode.id, ['contains']); + expect(contained.some((edge) => edge.target === alteredMember.id)).toBe(true); + expect(contained.some((edge) => edge.target === laterMember.id)).toBe(false); + expect(queries.getOutgoingEdges(recreatedEnum.id, ['contains']).some( + (edge) => edge.target === laterMember.id + )).toBe(true); + }); +}); diff --git a/__tests__/postgres-object-reference-intent.test.ts b/__tests__/postgres-object-reference-intent.test.ts new file mode 100644 index 000000000..64f9e63e9 --- /dev/null +++ b/__tests__/postgres-object-reference-intent.test.ts @@ -0,0 +1,332 @@ +/** + * PostgreSQL object-reference intents. + * + * Type and sequence uses share PostgreSQL's identifier/search_path rules with + * relation uses, but they must never bind to a same-named table (or fall into + * the generic framework/fuzzy pipeline). The internal intent is retained only + * until resolution; persisted graph edges remain ordinary `references`. + */ +import { afterEach, describe, expect, it } from 'vitest'; +import * as fs from 'node:fs'; +import * as os from 'node:os'; +import * as path from 'node:path'; +import { DatabaseConnection } from '../src/db'; +import { QueryBuilder } from '../src/db/queries'; +import { + POSTGRES_SEQUENCE_REFERENCE_KIND, + POSTGRES_TYPE_REFERENCE_KIND, +} from '../src/postgres/reference-intent'; +import { createResolver } from '../src/resolution'; +import { matchReference } from '../src/resolution/name-matcher'; +import type { ResolutionContext, UnresolvedRef } from '../src/resolution/types'; +import type { Language, Node, NodeKind, UnresolvedReference } from '../src/types'; + +interface NodeOptions { + id: string; + name: string; + qualifiedName: string; + filePath?: string; + kind?: NodeKind; + language?: Language; + decorators?: string[]; +} + +function makeNode(options: NodeOptions): Node { + return { + id: options.id, + name: options.name, + qualifiedName: options.qualifiedName, + filePath: options.filePath ?? 'migrations/001.sql', + kind: options.kind ?? 'struct', + language: options.language ?? 'postgres', + decorators: options.decorators, + startLine: 1, + endLine: 1, + startColumn: 0, + endColumn: 1, + updatedAt: 0, + }; +} + +function makeRef( + referenceName: string, + referenceKind: UnresolvedRef['referenceKind'], + filePath = 'migrations/consumer.sql' +): UnresolvedRef { + return { + fromNodeId: 'consumer', + referenceName, + referenceKind, + line: 2, + column: 1, + filePath, + language: 'postgres', + }; +} + +function contextFor(nodes: Node[], sources: Record = {}): ResolutionContext { + return { + getNodesInFile: (filePath) => nodes.filter((node) => node.filePath === filePath), + getNodesByName: (name) => nodes.filter((node) => node.name === name), + getNodesByQualifiedName: (name) => + nodes.filter((node) => node.qualifiedName === name), + getNodesByKind: (kind) => nodes.filter((node) => node.kind === kind), + fileExists: (filePath) => nodes.some((node) => node.filePath === filePath), + readFile: (filePath) => sources[filePath] ?? null, + getProjectRoot: () => '/project', + getAllFiles: () => [...new Set(nodes.map((node) => node.filePath))], + getNodesByLowerName: (name) => + nodes.filter((node) => node.name.toLowerCase() === name), + getImportMappings: () => [], + }; +} + +describe('PostgreSQL object-reference intent matching', () => { + it('keeps ordinary relation, type, and sequence targets disjoint', () => { + const table = makeNode({ + id: 'table', + name: 'status', + qualifiedName: 'public.status', + kind: 'struct', + decorators: ['postgres:table'], + }); + const type = makeNode({ + id: 'type', + name: 'status', + qualifiedName: 'public.status', + kind: 'enum', + decorators: ['postgres:enum'], + }); + const sequence = makeNode({ + id: 'sequence', + name: 'status', + qualifiedName: 'public.status', + kind: 'variable', + decorators: ['postgres:sequence'], + }); + const context = contextFor([table, type, sequence]); + + expect(matchReference(makeRef('public.status', 'references'), context)) + .toMatchObject({ targetNodeId: table.id }); + expect(matchReference(makeRef('public.status', POSTGRES_TYPE_REFERENCE_KIND), context)) + .toMatchObject({ targetNodeId: type.id }); + expect(matchReference(makeRef('public.status', POSTGRES_SEQUENCE_REFERENCE_KIND), context)) + .toMatchObject({ targetNodeId: sequence.id }); + }); + + it.each([ + ['enum', 'enum', 'postgres:enum'], + ['domain', 'type_alias', 'postgres:domain'], + ['composite type', 'type_alias', 'postgres:type'], + ] as const)('accepts a decorated PostgreSQL %s', (_label, kind, decorator) => { + const target = makeNode({ + id: decorator, + name: 'status', + qualifiedName: 'app.status', + kind, + decorators: [decorator], + }); + const decoy = makeNode({ + id: `${decorator}:decoy`, + name: 'status', + qualifiedName: 'app.status', + kind, + language: 'typescript', + decorators: [decorator], + }); + + expect(matchReference( + makeRef('app.status', POSTGRES_TYPE_REFERENCE_KIND), + contextFor([target, decoy]) + )).toMatchObject({ targetNodeId: target.id }); + }); + + it('preserves quoted identifiers, search_path order, and duplicate ambiguity', () => { + const filePath = 'migrations/consumer.sql'; + const source = 'SET search_path = app, public;\nSELECT 1;'; + const appType = makeNode({ + id: 'app-type', + name: 'Status.Type', + qualifiedName: 'app."Status.Type"', + kind: 'enum', + decorators: ['postgres:enum'], + }); + const publicType = makeNode({ + id: 'public-type', + name: 'Status.Type', + qualifiedName: 'public."Status.Type"', + kind: 'enum', + decorators: ['postgres:enum'], + }); + const context = contextFor([appType, publicType], { [filePath]: source }); + + expect(matchReference( + makeRef('"Status.Type"', POSTGRES_TYPE_REFERENCE_KIND, filePath), + context + )).toMatchObject({ targetNodeId: appType.id }); + + const duplicate = makeNode({ + ...appType, + id: 'app-type-v2', + filePath: 'migrations/002.sql', + }); + expect(matchReference( + makeRef('app."Status.Type"', POSTGRES_TYPE_REFERENCE_KIND, filePath), + contextFor([appType, duplicate]) + )).toBeNull(); + }); + + it('rejects undecorated and wrong-class PostgreSQL nodes', () => { + const nodes = [ + makeNode({ + id: 'undecorated-type', + name: 'status', + qualifiedName: 'public.status', + kind: 'enum', + }), + makeNode({ + id: 'wrong-type', + name: 'status', + qualifiedName: 'public.status', + kind: 'enum', + decorators: ['postgres:sequence'], + }), + makeNode({ + id: 'wrong-sequence', + name: 'events_id_seq', + qualifiedName: 'public.events_id_seq', + kind: 'variable', + decorators: ['postgres:type'], + }), + ]; + const context = contextFor(nodes); + + expect(matchReference( + makeRef('public.status', POSTGRES_TYPE_REFERENCE_KIND), + context + )).toBeNull(); + expect(matchReference( + makeRef('public.events_id_seq', POSTGRES_SEQUENCE_REFERENCE_KIND), + context + )).toBeNull(); + }); +}); + +describe('PostgreSQL object-reference intent persistence', () => { + const cleanup: Array<{ dir: string; db: DatabaseConnection }> = []; + + afterEach(() => { + for (const item of cleanup.splice(0)) { + item.db.close(); + fs.rmSync(item.dir, { recursive: true, force: true }); + } + }); + + it('materializes quoted search_path matches as ordinary references edges', () => { + const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-pg-object-ref-')); + const db = DatabaseConnection.initialize(path.join(dir, 'test.db')); + cleanup.push({ dir, db }); + const queries = new QueryBuilder(db.getDb()); + const consumerPath = 'consumer.sql'; + fs.writeFileSync( + path.join(dir, consumerPath), + 'SET search_path = app;\nSELECT 1;\nSELECT 2;\n' + ); + fs.writeFileSync(path.join(dir, 'types.sql'), ''); + fs.writeFileSync(path.join(dir, 'sequences.sql'), ''); + + const consumer = makeNode({ + id: 'consumer', + name: 'consumer.sql', + qualifiedName: consumerPath, + filePath: consumerPath, + kind: 'file', + }); + const type = makeNode({ + id: 'type', + name: 'Status.Type', + qualifiedName: 'app."Status.Type"', + filePath: 'types.sql', + kind: 'enum', + decorators: ['postgres:enum'], + }); + const typeDecoy = makeNode({ + id: 'type-decoy-table', + name: 'Status.Type', + qualifiedName: 'app."Status.Type"', + filePath: 'types.sql', + kind: 'struct', + decorators: ['postgres:table'], + }); + const sequence = makeNode({ + id: 'sequence', + name: 'Seq.Name', + qualifiedName: 'app."Seq.Name"', + filePath: 'sequences.sql', + kind: 'variable', + decorators: ['postgres:sequence'], + }); + const sequenceDecoy = makeNode({ + id: 'sequence-decoy-type', + name: 'Seq.Name', + qualifiedName: 'app."Seq.Name"', + filePath: 'sequences.sql', + kind: 'type_alias', + decorators: ['postgres:type'], + }); + for (const node of [consumer, type, typeDecoy, sequence, sequenceDecoy]) { + queries.insertNode(node); + } + + const refs: UnresolvedReference[] = [ + { + fromNodeId: consumer.id, + referenceName: '"Status.Type"', + referenceKind: POSTGRES_TYPE_REFERENCE_KIND, + line: 2, + column: 1, + filePath: consumerPath, + language: 'postgres', + }, + { + fromNodeId: consumer.id, + referenceName: '"Seq.Name"', + referenceKind: POSTGRES_SEQUENCE_REFERENCE_KIND, + line: 3, + column: 1, + filePath: consumerPath, + language: 'postgres', + }, + ]; + queries.insertUnresolvedRefsBatch(refs); + + const resolver = createResolver(dir, queries); + const result = resolver.resolveAndPersist(queries.getUnresolvedReferences()); + expect(result.resolved).toHaveLength(2); + expect(result.unresolved).toEqual([]); + + const edges = queries.getOutgoingEdges(consumer.id); + expect(edges).toEqual(expect.arrayContaining([ + expect.objectContaining({ + target: type.id, + kind: 'references', + metadata: expect.objectContaining({ + refKind: POSTGRES_TYPE_REFERENCE_KIND, + refName: '"Status.Type"', + }), + }), + expect.objectContaining({ + target: sequence.id, + kind: 'references', + metadata: expect.objectContaining({ + refKind: POSTGRES_SEQUENCE_REFERENCE_KIND, + refName: '"Seq.Name"', + }), + }), + ])); + expect(edges.some((edge) => + edge.target === typeDecoy.id || edge.target === sequenceDecoy.id + )).toBe(false); + expect(queries.getUnresolvedReferencesCount()).toBe(0); + }); +}); diff --git a/__tests__/postgres-plpgsql-grammar.test.ts b/__tests__/postgres-plpgsql-grammar.test.ts new file mode 100644 index 000000000..e71d42a5f --- /dev/null +++ b/__tests__/postgres-plpgsql-grammar.test.ts @@ -0,0 +1,47 @@ +import { createHash } from 'node:crypto'; +import { beforeAll, describe, expect, it } from 'vitest'; +import { + getPostgresPlpgsqlParser, + initGrammars, + loadGrammarsForLanguages, + readGrammarWasmBytes, +} from '../src/extraction/grammars'; + +describe('PostgreSQL PL/pgSQL companion grammar', () => { + beforeAll(async () => { + await initGrammars(); + await loadGrammarsForLanguages(['postgres']); + }); + + it('pre-reads the pinned companion bytes with the PostgreSQL grammar', async () => { + const bytes = await readGrammarWasmBytes(['postgres']); + + expect(bytes.postgres).toBeInstanceOf(Uint8Array); + expect(bytes.plpgsql).toBeInstanceOf(Uint8Array); + expect(bytes.plpgsql.byteLength).toBe(137_462); + expect(createHash('sha256').update(bytes.plpgsql).digest('hex')).toBe( + '24a4b44b5263cbf78716d5a7301b5ade6f8696dbce08365421e785382427694e' + ); + }); + + it('loads a dedicated parser that structurally separates embedded SQL', () => { + const parser = getPostgresPlpgsqlParser(); + expect(parser).not.toBeNull(); + + const tree = parser!.parse([ + 'DECLARE', + ' selected_id uuid;', + 'BEGIN', + ' SELECT id INTO selected_id FROM public.users WHERE active;', + ' PERFORM public.touch_user(selected_id);', + 'END;', + ].join('\n')); + + expect(tree.rootNode.hasError).toBe(false); + const syntax = tree.rootNode.toString(); + expect(syntax).toContain('(pl_block '); + expect(syntax).toContain('(stmt_execsql (sql_expression))'); + expect(syntax).toContain('(stmt_perform (kw_perform) (sql_expression))'); + tree.delete(); + }); +}); diff --git a/__tests__/postgres-preparse-resolution.test.ts b/__tests__/postgres-preparse-resolution.test.ts new file mode 100644 index 000000000..aba7bec35 --- /dev/null +++ b/__tests__/postgres-preparse-resolution.test.ts @@ -0,0 +1,68 @@ +import { beforeAll, describe, expect, it } from 'vitest'; +import * as fs from 'node:fs'; +import * as os from 'node:os'; +import * as path from 'node:path'; +import { CodeGraph } from '../src'; +import { initGrammars, loadGrammarsForLanguages } from '../src/extraction/grammars'; + +beforeAll(async () => { + await initGrammars(); + await loadGrammarsForLanguages(['postgres']); +}); + +async function indexedPostgres(source: string): Promise<{ + graph: CodeGraph; + projectDir: string; +}> { + const projectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-pg-preparse-')); + fs.writeFileSync(path.join(projectDir, 'schema.sql'), `${source.trim()}\n`); + const graph = CodeGraph.initSync(projectDir); + await graph.indexAll(); + return { graph, projectDir }; +} + +function referencedTableNames(graph: CodeGraph, line: number): string[] { + const file = graph.getNodesByQualifiedName('schema.sql') + .find((node) => node.kind === 'file')!; + return graph.getOutgoingEdges(file.id, ['references']) + .filter((edge) => edge.line === line) + .map((edge) => graph.getNode(edge.target)) + .filter((node) => node?.language === 'postgres' && node.kind === 'struct') + .map((node) => node!.qualifiedName); +} + +describe('PostgreSQL prepared-source resolution parity', () => { + it('does not let a psql meta-command swallow the following SET search_path', async () => { + const { graph, projectDir } = await indexedPostgres([ + '\\set tenant app', + 'SET search_path = app;', + 'CREATE TABLE app.users (id bigint);', + 'SELECT * FROM users;', + ].join('\n')); + try { + expect(referencedTableNames(graph, 4)).toEqual(['app.users']); + } finally { + graph.destroy(); + fs.rmSync(projectDir, { recursive: true, force: true }); + } + }); + + it('does not treat COPY FROM STDIN payload text as a search_path change', async () => { + const { graph, projectDir } = await indexedPostgres([ + 'CREATE TABLE app.users (id bigint);', + 'CREATE TABLE history.users (id bigint);', + 'CREATE TABLE public.seed (value text);', + 'SET search_path = app;', + 'COPY public.seed FROM STDIN WITH (FORMAT csv);', + 'SET search_path = history;', + '\\.', + 'SELECT * FROM users;', + ].join('\n')); + try { + expect(referencedTableNames(graph, 8)).toEqual(['app.users']); + } finally { + graph.destroy(); + fs.rmSync(projectDir, { recursive: true, force: true }); + } + }); +}); diff --git a/__tests__/postgres-relation-lifecycle-resolution.test.ts b/__tests__/postgres-relation-lifecycle-resolution.test.ts new file mode 100644 index 000000000..9dee42b7b --- /dev/null +++ b/__tests__/postgres-relation-lifecycle-resolution.test.ts @@ -0,0 +1,165 @@ +import { beforeAll, describe, expect, it } from 'vitest'; +import * as fs from 'node:fs'; +import * as os from 'node:os'; +import * as path from 'node:path'; +import { CodeGraph } from '../src'; +import { initGrammars, loadGrammarsForLanguages } from '../src/extraction/grammars'; +import { POSTGRES_DROP_RELATION_DECORATOR } from '../src/postgres/relation-lifecycle'; + +beforeAll(async () => { + await initGrammars(); + await loadGrammarsForLanguages(['postgres']); +}); + +function withMigrationProject(files: Record): string { + const projectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-pg-lifecycle-')); + for (const [file, source] of Object.entries(files)) { + fs.writeFileSync(path.join(projectDir, file), `${source.trim()}\n`); + } + return projectDir; +} + +describe('PostgreSQL relation lifecycle resolution', () => { + it('attaches a later-file FK to the table declaration after DROP and re-CREATE', async () => { + const projectDir = withMigrationProject({ + '001_users.sql': 'CREATE TABLE public.users (id bigint PRIMARY KEY);', + '002_orders.sql': [ + 'CREATE TABLE public.orders (', + ' id bigint PRIMARY KEY,', + ' user_id bigint', + ');', + ].join('\n'), + '003_drop_orders.sql': 'DROP TABLE public.orders;', + '004_recreate_orders.sql': [ + 'CREATE TABLE public.orders (', + ' id bigint PRIMARY KEY,', + ' user_id bigint', + ');', + ].join('\n'), + '005_orders_fk.sql': [ + 'ALTER TABLE public.orders', + ' ADD CONSTRAINT orders_user_fk', + ' FOREIGN KEY (user_id) REFERENCES public.users(id);', + ].join('\n'), + }); + const graph = CodeGraph.initSync(projectDir); + try { + await graph.indexAll(); + + const users = graph.getNodesByQualifiedName('public.users')[0]!; + const orders = graph.getNodesByQualifiedName('public.orders'); + const oldOrders = orders.find((node) => node.filePath === '002_orders.sql')!; + const recreatedOrders = orders.find((node) => node.filePath === '004_recreate_orders.sql')!; + expect(users).toBeTruthy(); + expect(oldOrders).toBeTruthy(); + expect(recreatedOrders).toBeTruthy(); + expect(graph.getOutgoingEdges(oldOrders.id)).not.toEqual(expect.arrayContaining([ + expect.objectContaining({ + target: users.id, + metadata: expect.objectContaining({ postgresRelation: 'foreign-key' }), + }), + ])); + expect(graph.getOutgoingEdges(recreatedOrders.id)).toEqual(expect.arrayContaining([ + expect.objectContaining({ + target: users.id, + kind: 'references', + metadata: expect.objectContaining({ postgresRelation: 'foreign-key' }), + }), + ])); + } finally { + graph.destroy(); + fs.rmSync(projectDir, { recursive: true, force: true }); + } + }); + + it('resolves each DROP VIEW to the latest preceding historical definition', async () => { + const projectDir = withMigrationProject({ + '001_create_view.sql': 'CREATE VIEW app.summary AS SELECT 1 AS value;', + '002_drop_view.sql': 'DROP VIEW app.summary;', + '003_recreate_view.sql': 'CREATE VIEW app.summary AS SELECT 2 AS value;', + '004_drop_view.sql': 'DROP VIEW app.summary;', + }); + const graph = CodeGraph.initSync(projectDir); + try { + await graph.indexAll(); + + const views = graph.getNodesByQualifiedName('app.summary'); + const original = views.find((node) => node.filePath === '001_create_view.sql')!; + const recreated = views.find((node) => node.filePath === '003_recreate_view.sql')!; + const drops = graph.getNodesByName('DROP VIEW app.summary') + .filter((node) => node.decorators?.includes(POSTGRES_DROP_RELATION_DECORATOR)); + const firstDrop = drops.find((node) => node.filePath === '002_drop_view.sql')!; + const secondDrop = drops.find((node) => node.filePath === '004_drop_view.sql')!; + expect(graph.getOutgoingEdges(firstDrop.id)).toEqual(expect.arrayContaining([ + expect.objectContaining({ target: original.id, kind: 'references' }), + ])); + expect(graph.getOutgoingEdges(secondDrop.id)).toEqual(expect.arrayContaining([ + expect.objectContaining({ target: recreated.id, kind: 'references' }), + ])); + } finally { + graph.destroy(); + fs.rmSync(projectDir, { recursive: true, force: true }); + } + }); + + it('does not resolve a DROP to a later declaration in the same file', async () => { + const projectDir = withMigrationProject({ + '001_create_orders.sql': 'CREATE TABLE public.orders (id bigint);', + '002_replace_orders.sql': [ + 'DROP TABLE public.orders;', + 'CREATE TABLE public.orders (id bigint);', + ].join('\n'), + }); + const graph = CodeGraph.initSync(projectDir); + try { + await graph.indexAll(); + + const orders = graph.getNodesByQualifiedName('public.orders'); + const original = orders.find((node) => node.filePath === '001_create_orders.sql')!; + const recreated = orders.find((node) => node.filePath === '002_replace_orders.sql')!; + const drop = graph.getNodesByName('DROP TABLE public.orders') + .find((node) => node.decorators?.includes(POSTGRES_DROP_RELATION_DECORATOR))!; + const targets = graph.getOutgoingEdges(drop.id) + .filter((edge) => edge.kind === 'references') + .map((edge) => edge.target); + + expect(original).toBeTruthy(); + expect(recreated).toBeTruthy(); + expect(drop).toBeTruthy(); + expect(targets).toContain(original.id); + expect(targets).not.toContain(recreated.id); + } finally { + graph.destroy(); + fs.rmSync(projectDir, { recursive: true, force: true }); + } + }); + + it('renames the recreated relation after a DROP boundary', async () => { + const projectDir = withMigrationProject({ + '001_create_orders.sql': 'CREATE TABLE public.orders (id bigint);', + '002_drop_orders.sql': 'DROP TABLE public.orders;', + '003_recreate_orders.sql': 'CREATE TABLE public.orders (id bigint);', + '004_rename_orders.sql': 'ALTER TABLE public.orders RENAME TO purchases;', + }); + const graph = CodeGraph.initSync(projectDir); + try { + await graph.indexAll(); + + const orders = graph.getNodesByQualifiedName('public.orders'); + const original = orders.find((node) => node.filePath === '001_create_orders.sql')!; + const recreated = orders.find((node) => node.filePath === '003_recreate_orders.sql')!; + const purchases = graph.getNodesByQualifiedName('public.purchases')[0]!; + const isRenameToPurchases = (edge: ReturnType[number]) => + edge.target === purchases.id && edge.metadata?.postgresRelation === 'rename'; + + expect(original).toBeTruthy(); + expect(recreated).toBeTruthy(); + expect(purchases).toBeTruthy(); + expect(graph.getOutgoingEdges(recreated.id).some(isRenameToPurchases)).toBe(true); + expect(graph.getOutgoingEdges(original.id).some(isRenameToPurchases)).toBe(false); + } finally { + graph.destroy(); + fs.rmSync(projectDir, { recursive: true, force: true }); + } + }); +}); diff --git a/__tests__/postgres-rename-regressions.test.ts b/__tests__/postgres-rename-regressions.test.ts new file mode 100644 index 000000000..7b96296b2 --- /dev/null +++ b/__tests__/postgres-rename-regressions.test.ts @@ -0,0 +1,163 @@ +import { beforeAll, describe, expect, it } from 'vitest'; +import * as fs from 'node:fs'; +import * as os from 'node:os'; +import * as path from 'node:path'; +import { CodeGraph } from '../src'; +import { extractFromSource } from '../src/extraction'; +import { initGrammars, loadGrammarsForLanguages } from '../src/extraction/grammars'; +import { + POSTGRES_TABLE_RELATION_DECORATOR, + decodePostgresTableRelationDescriptor, +} from '../src/postgres/table-relation'; + +beforeAll(async () => { + await initGrammars(); + await loadGrammarsForLanguages(['postgres']); +}); + +function extract(source: string) { + return extractFromSource('db/renames.sql', source, 'postgres'); +} + +describe('PostgreSQL rename regressions', () => { + it('extracts view and materialized-view renames as relation aliases', () => { + const result = extract([ + 'CREATE VIEW app.old_view AS SELECT 1 AS id;', + 'CREATE MATERIALIZED VIEW app.old_mv AS SELECT 1 AS id;', + 'ALTER VIEW app.old_view RENAME TO active_view;', + 'ALTER MATERIALIZED VIEW app.old_mv RENAME TO active_mv;', + ].join('\n')); + + expect(result.errors).toEqual([]); + expect(result.nodes.find((node) => node.qualifiedName === 'app.active_view')) + .toMatchObject({ + kind: 'struct', + decorators: expect.arrayContaining(['postgres:view', 'postgres:renamed-relation']), + }); + expect(result.nodes.find((node) => node.qualifiedName === 'app.active_mv')) + .toMatchObject({ + kind: 'struct', + decorators: expect.arrayContaining([ + 'postgres:materialized-view', + 'postgres:renamed-relation', + ]), + }); + expect(result.nodes.filter((node) => + node.decorators?.includes('postgres:renamed-type') + )).toEqual([]); + + const renames = result.nodes + .filter((node) => node.decorators?.includes(POSTGRES_TABLE_RELATION_DECORATOR)) + .map((node) => decodePostgresTableRelationDescriptor(node.decorators)); + expect(renames).toEqual(expect.arrayContaining([ + { + relation: 'rename', + sourceTable: 'app.old_view', + targetTable: 'app.active_view', + }, + { + relation: 'rename', + sourceTable: 'app.old_mv', + targetTable: 'app.active_mv', + }, + ])); + }); + + it('models ALTER TYPE RENAME VALUE at the new label, separately from ADD VALUE', () => { + const result = extract([ + "CREATE TYPE app.status AS ENUM ('old');", + "ALTER TYPE app.status ADD VALUE 'added';", + "ALTER TYPE app.status RENAME VALUE 'old' TO 'new';", + ].join('\n')); + + expect(result.errors).toEqual([]); + const added = result.nodes.find((node) => + node.qualifiedName === 'app.status.added' && + node.decorators?.includes('postgres:alter-enum-add-value') + ); + const renamed = result.nodes.find((node) => + node.qualifiedName === 'app.status.new' && + node.decorators?.includes('postgres:renamed-enum-value') + ); + expect(added).toBeTruthy(); + expect(renamed).toMatchObject({ + name: 'new', + kind: 'enum_member', + decorators: expect.arrayContaining([ + 'postgres:enum-value', + 'postgres:renamed-enum-value', + ]), + }); + expect(renamed?.decorators).not.toContain('postgres:alter-enum-add-value'); + expect(result.nodes.filter((node) => node.qualifiedName === 'app.status.old')) + .toHaveLength(1); + }); + + it('resolves renamed relation aliases and synthesizes their rename trails', async () => { + const projectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-postgres-renames-')); + fs.writeFileSync( + path.join(projectDir, '001_relations.sql'), + [ + 'CREATE VIEW app.old_view AS SELECT 1 AS id;', + 'CREATE MATERIALIZED VIEW app.old_mv AS SELECT 1 AS id;', + "CREATE TYPE app.status AS ENUM ('old');", + ].join('\n') + '\n' + ); + fs.writeFileSync( + path.join(projectDir, '002_renames.sql'), + [ + 'ALTER VIEW app.old_view RENAME TO active_view;', + 'ALTER MATERIALIZED VIEW app.old_mv RENAME TO active_mv;', + "ALTER TYPE app.status RENAME VALUE 'old' TO 'new';", + ].join('\n') + '\n' + ); + fs.writeFileSync( + path.join(projectDir, '003_consumers.sql'), + [ + 'CREATE VIEW app.view_consumer AS SELECT * FROM app.active_view;', + 'CREATE VIEW app.mv_consumer AS SELECT * FROM app.active_mv;', + ].join('\n') + '\n' + ); + + const graph = CodeGraph.initSync(projectDir); + try { + await graph.indexAll(); + + const oldView = graph.getNodesByQualifiedName('app.old_view')[0]!; + const activeView = graph.getNodesByQualifiedName('app.active_view')[0]!; + const oldMv = graph.getNodesByQualifiedName('app.old_mv')[0]!; + const activeMv = graph.getNodesByQualifiedName('app.active_mv')[0]!; + const viewConsumer = graph.getNodesByQualifiedName('app.view_consumer')[0]!; + const mvConsumer = graph.getNodesByQualifiedName('app.mv_consumer')[0]!; + + expect(graph.getOutgoingEdges(oldView.id)).toEqual(expect.arrayContaining([ + expect.objectContaining({ + target: activeView.id, + metadata: expect.objectContaining({ postgresRelation: 'rename' }), + }), + ])); + expect(graph.getOutgoingEdges(oldMv.id)).toEqual(expect.arrayContaining([ + expect.objectContaining({ + target: activeMv.id, + metadata: expect.objectContaining({ postgresRelation: 'rename' }), + }), + ])); + expect(graph.getOutgoingEdges(viewConsumer.id)).toEqual(expect.arrayContaining([ + expect.objectContaining({ target: activeView.id, kind: 'references' }), + ])); + expect(graph.getOutgoingEdges(mvConsumer.id)).toEqual(expect.arrayContaining([ + expect.objectContaining({ target: activeMv.id, kind: 'references' }), + ])); + + const status = graph.getNodesByQualifiedName('app.status')[0]!; + const renamedValue = graph.getNodesByQualifiedName('app.status.new')[0]!; + expect(renamedValue.decorators).toContain('postgres:renamed-enum-value'); + expect(graph.getOutgoingEdges(status.id)).toEqual(expect.arrayContaining([ + expect.objectContaining({ target: renamedValue.id, kind: 'contains' }), + ])); + } finally { + graph.destroy(); + fs.rmSync(projectDir, { recursive: true, force: true }); + } + }); +}); diff --git a/__tests__/postgres-routine-body.test.ts b/__tests__/postgres-routine-body.test.ts new file mode 100644 index 000000000..859abc630 --- /dev/null +++ b/__tests__/postgres-routine-body.test.ts @@ -0,0 +1,194 @@ +import type { Node as SyntaxNode } from 'web-tree-sitter'; +import { beforeAll, describe, expect, it } from 'vitest'; +import { + getParser, + getPostgresPlpgsqlParser, + initGrammars, + loadGrammarsForLanguages, +} from '../src/extraction/grammars'; +import { + discoverPostgresRoutineBodyReferences, + type PostgresRoutineBodyReference, +} from '../src/postgres/routine-body'; + +function firstDescendant(node: SyntaxNode, type: string): SyntaxNode | null { + for (let index = 0; index < node.namedChildCount; index++) { + const child = node.namedChild(index); + if (!child) continue; + if (child.type === type) return child; + const nested = firstDescendant(child, type); + if (nested) return nested; + } + return null; +} + +function expectedPosition(source: string, startIndex: number) { + const before = source.slice(0, startIndex); + const lineStart = before.lastIndexOf('\n') + 1; + return { + startIndex, + line: before.split('\n').length, + column: startIndex - lineStart, + }; +} + +function findFact( + facts: PostgresRoutineBodyReference[], + kind: PostgresRoutineBodyReference['kind'], + qualifiedName: string +) { + return facts.find((fact) => fact.kind === kind && fact.qualifiedName === qualifiedName); +} + +describe('PostgreSQL routine body reference discovery', () => { + beforeAll(async () => { + await initGrammars(); + await loadGrammarsForLanguages(['postgres']); + }); + + function analyze(source: string, statementType: 'CreateFunctionStmt' | 'DoStmt') { + const postgres = getParser('postgres')!; + const outerTree = postgres.parse(source); + const statement = firstDescendant(outerTree.rootNode, statementType); + expect(statement).not.toBeNull(); + const result = discoverPostgresRoutineBodyReferences(statement!, source, { + postgres, + plpgsql: getPostgresPlpgsqlParser(), + }); + outerTree.delete(); + return result; + } + + it('indexes SQL-language bodies with CTE suppression, de-duplication, and outer offsets', () => { + const source = [ + '-- leading line keeps nested coordinates honest', + 'CREATE FUNCTION app.find_users() RETURNS SETOF uuid', + 'LANGUAGE sql', + 'AS $body$', + 'WITH selected AS (', + ' SELECT id FROM "App"."Users"', + ')', + "SELECT public.touch_user(id), nextval('public.job_seq'::regclass)", + 'FROM selected', + 'JOIN public.accounts ON true', + 'JOIN "App"."Users" again ON true;', + '$body$;', + ].join('\n'); + + const result = analyze(source, 'CreateFunctionStmt'); + expect(result.status).toBe('analyzed'); + expect(result.language).toBe('sql'); + expect(result.facts.map((fact) => [fact.kind, fact.qualifiedName])).toEqual([ + ['references', '"App"."Users"'], + ['calls', 'public.touch_user'], + ['calls', 'nextval'], + ['sequence', 'public.job_seq'], + ['references', 'public.accounts'], + ]); + expect(result.facts.some((fact) => fact.qualifiedName === 'selected')).toBe(false); + + const usersIndex = source.indexOf('"App"."Users"'); + expect(findFact(result.facts, 'references', '"App"."Users"')).toMatchObject( + expectedPosition(source, usersIndex) + ); + }); + + it('uses PL/pgSQL regions, safely recovers INTO, and skips dynamic SQL and record fields', () => { + const source = [ + 'CREATE FUNCTION public.touch_submission() RETURNS trigger', + 'AS $fn$', + 'DECLARE selected_id uuid;', + 'BEGIN', + ' WITH chosen AS (SELECT id FROM public.users)', + ' SELECT id INTO selected_id FROM chosen;', + ' UPDATE public.accounts SET active = true', + ' WHERE user_id = selected_id RETURNING id INTO selected_id;', + ' PERFORM public.touch_user(selected_id);', + " EXECUTE format('DELETE FROM public.secret_table WHERE id = %L', selected_id);", + ' NEW.updated_at := now();', + ' RETURN NEW;', + 'END;', + '$fn$', + 'LANGUAGE plpgsql;', + ].join('\n'); + + const result = analyze(source, 'CreateFunctionStmt'); + expect(result.status).toBe('analyzed'); + expect(result.language).toBe('plpgsql'); + expect(result.recoveredFragments).toBeGreaterThan(0); + expect(result.skippedDynamicFragments).toBeGreaterThan(0); + expect(result.facts.map((fact) => [fact.kind, fact.qualifiedName])).toEqual([ + ['references', 'public.users'], + ['references', 'public.accounts'], + ['calls', 'public.touch_user'], + ['calls', 'now'], + ]); + expect(result.facts.some((fact) => fact.qualifiedName === 'chosen')).toBe(false); + expect(result.facts.some((fact) => fact.qualifiedName.includes('secret_table'))).toBe(false); + expect(result.facts.some((fact) => fact.qualifiedName.startsWith('new.'))).toBe(false); + + const accountsIndex = source.indexOf('public.accounts'); + expect(findFact(result.facts, 'references', 'public.accounts')).toMatchObject( + expectedPosition(source, accountsIndex) + ); + const touchIndex = source.indexOf('public.touch_user'); + expect(findFact(result.facts, 'calls', 'public.touch_user')).toMatchObject( + expectedPosition(source, touchIndex) + ); + }); + + it('treats DO as PL/pgSQL by default and maps tagged body coordinates', () => { + const source = [ + 'DO $migration$', + 'BEGIN', + ' INSERT INTO audit.events(id) VALUES (gen_random_uuid());', + 'END;', + '$migration$;', + ].join('\n'); + + const result = analyze(source, 'DoStmt'); + expect(result.status).toBe('analyzed'); + expect(result.language).toBe('plpgsql'); + expect(result.facts.map((fact) => [fact.kind, fact.qualifiedName])).toEqual([ + ['references', 'audit.events'], + ['calls', 'gen_random_uuid'], + ]); + const eventsIndex = source.indexOf('audit.events'); + expect(findFact(result.facts, 'references', 'audit.events')).toMatchObject( + expectedPosition(source, eventsIndex) + ); + }); + + it('rejects an invalid SQL body instead of trusting error recovery', () => { + const source = [ + 'CREATE FUNCTION public.broken() RETURNS void', + 'LANGUAGE sql AS $$', + 'SELECT (((;', + '$$;', + ].join('\n'); + + const result = analyze(source, 'CreateFunctionStmt'); + expect(result.status).toBe('parse-error'); + expect(result.facts).toEqual([]); + }); + + it('accepts only literal sequence arguments through parentheses and casts', () => { + const source = [ + 'CREATE FUNCTION public.sequence_values(tenant text) RETURNS bigint', + 'LANGUAGE sql AS $$', + "SELECT nextval((('public.literal_seq'))::regclass),", + " setval(CAST('public.cast_seq' AS regclass), 1),", + " nextval(('public.foo_' || tenant)::regclass),", + " nextval(format('public.%s_seq', tenant)::regclass);", + '$$;', + ].join('\n'); + + const result = analyze(source, 'CreateFunctionStmt'); + expect(result.status).toBe('analyzed'); + expect(result.facts + .filter((fact) => fact.kind === 'sequence') + .map((fact) => fact.qualifiedName) + .sort() + ).toEqual(['public.cast_seq', 'public.literal_seq']); + }); +}); diff --git a/__tests__/postgres-routine-search-path.test.ts b/__tests__/postgres-routine-search-path.test.ts new file mode 100644 index 000000000..02db733de --- /dev/null +++ b/__tests__/postgres-routine-search-path.test.ts @@ -0,0 +1,239 @@ +import type { Node as SyntaxNode } from 'web-tree-sitter'; +import { beforeAll, describe, expect, it } from 'vitest'; +import { extractFromSource } from '../src/extraction'; +import { + getParser, + getPostgresPlpgsqlParser, + initGrammars, + loadGrammarsForLanguages, +} from '../src/extraction/grammars'; +import { discoverPostgresRoutineBodyReferences } from '../src/postgres/routine-body'; +import { matchReference } from '../src/resolution/name-matcher'; +import type { ResolutionContext, UnresolvedRef } from '../src/resolution/types'; +import type { Node } from '../src/types'; + +function firstDescendant(node: SyntaxNode, type: string): SyntaxNode | null { + for (let index = 0; index < node.namedChildCount; index++) { + const child = node.namedChild(index); + if (!child) continue; + if (child.type === type) return child; + const nested = firstDescendant(child, type); + if (nested) return nested; + } + return null; +} + +function analyze(source: string) { + const postgres = getParser('postgres')!; + const tree = postgres.parse(source); + const statement = firstDescendant(tree.rootNode, 'CreateFunctionStmt'); + expect(statement).not.toBeNull(); + const discovery = discoverPostgresRoutineBodyReferences(statement!, source, { + postgres, + plpgsql: getPostgresPlpgsqlParser(), + }); + tree.delete(); + return discovery; +} + +function table(id: string, qualifiedName: string, filePath = `${id}.sql`): Node { + const name = qualifiedName.slice(qualifiedName.lastIndexOf('.') + 1).replace(/^"|"$/g, ''); + return { + id, + kind: 'struct', + name, + qualifiedName, + filePath, + language: 'postgres', + decorators: ['postgres:table'], + startLine: 1, + endLine: 1, + startColumn: 0, + endColumn: 1, + updatedAt: 0, + }; +} + +function contextFor(nodes: Node[], source = 'SET search_path = outer;\nSELECT 1;'): ResolutionContext { + return { + getNodesInFile: (filePath) => nodes.filter((node) => node.filePath === filePath), + getNodesByName: (name) => nodes.filter((node) => node.name === name), + getNodesByQualifiedName: (qualifiedName) => + nodes.filter((node) => node.qualifiedName === qualifiedName), + getNodesByKind: (kind) => nodes.filter((node) => node.kind === kind), + fileExists: (filePath) => nodes.some((node) => node.filePath === filePath), + readFile: (filePath) => filePath === 'routine.sql' ? source : '', + getProjectRoot: () => '/project', + getAllFiles: () => [...new Set(nodes.map((node) => node.filePath))], + getNodesByLowerName: (lowerName) => + nodes.filter((node) => node.name.toLowerCase() === lowerName), + getImportMappings: () => [], + }; +} + +function routineRef(candidates: string[]): UnresolvedRef { + return { + fromNodeId: 'routine', + referenceName: 'jobs', + referenceKind: 'references', + line: 2, + column: 1, + filePath: 'routine.sql', + language: 'postgres', + candidates, + }; +} + +describe('PostgreSQL routine-local search_path', () => { + beforeAll(async () => { + await initGrammars(); + await loadGrammarsForLanguages(['postgres']); + }); + + it('qualifies SQL-body references with a single quoted schema', () => { + const source = [ + 'CREATE FUNCTION app.read_users() RETURNS SETOF record', + 'AS $$ SELECT touch_user(id) FROM users JOIN public.audit ON true $$', + 'LANGUAGE sql', + 'SET "search_path" TO "Tenant.Schema";', + ].join('\n'); + + const result = analyze(source); + expect(result.status).toBe('analyzed'); + expect(result.facts.map((fact) => [fact.kind, fact.qualifiedName])).toEqual([ + ['calls', '"Tenant.Schema".touch_user'], + ['references', '"Tenant.Schema".users'], + ['references', 'public.audit'], + ]); + expect(result.facts.every((fact) => fact.searchPathCandidates === undefined)).toBe(true); + }); + + it('keeps PL/pgSQL procedure alternatives ordered instead of linking every schema', () => { + const source = [ + 'CREATE PROCEDURE run_jobs()', + 'LANGUAGE plpgsql', + 'SET search_path = app, public', + 'AS $$', + 'BEGIN', + " INSERT INTO jobs(id) VALUES (nextval('job_seq'));", + ' PERFORM notify_job();', + 'END', + '$$;', + ].join('\n'); + + const result = analyze(source); + expect(result.status).toBe('analyzed'); + expect(result.facts.map((fact) => ({ + kind: fact.kind, + name: fact.qualifiedName, + candidates: fact.searchPathCandidates, + }))).toEqual([ + { kind: 'references', name: 'jobs', candidates: ['app.jobs', 'public.jobs'] }, + { kind: 'calls', name: 'nextval', candidates: ['app.nextval', 'public.nextval'] }, + { kind: 'sequence', name: 'job_seq', candidates: ['app.job_seq', 'public.job_seq'] }, + { kind: 'calls', name: 'notify_job', candidates: ['app.notify_job', 'public.notify_job'] }, + ]); + }); + + it('captures FROM CURRENT without changing the surrounding file path', () => { + const source = [ + 'SET search_path = "Creation.Schema";', + 'CREATE FUNCTION read_users() RETURNS SETOF record', + 'SET search_path FROM CURRENT', + 'LANGUAGE sql', + 'AS $$ SELECT * FROM users $$;', + 'SELECT * FROM users;', + ].join('\n'); + + const facts = analyze(source).facts; + expect(facts).toHaveLength(1); + expect(facts[0]).toMatchObject({ qualifiedName: '"Creation.Schema".users' }); + expect(facts[0]).not.toHaveProperty('searchPathCandidates'); + + const extracted = extractFromSource('db/schema.sql', source, 'postgres'); + const routine = extracted.nodes.find((node) => node.decorators?.includes('postgres:function'))!; + const routineReference = extracted.unresolvedReferences.find( + (reference) => reference.fromNodeId === routine.id && reference.referenceName.endsWith('.users') + ); + const fileReference = extracted.unresolvedReferences.find( + (reference) => reference.fromNodeId !== routine.id && reference.referenceName === 'users' + ); + expect(routineReference).toMatchObject({ + referenceName: '"Creation.Schema".users', + }); + expect(fileReference).toMatchObject({ referenceName: 'users' }); + expect(routineReference).not.toHaveProperty('candidates'); + expect(fileReference).not.toHaveProperty('candidates'); + }); + + it('persists multiple and empty routine paths without altering the ambient path', () => { + const source = [ + 'SET search_path = outer;', + 'CREATE PROCEDURE run_jobs()', + 'LANGUAGE plpgsql SET search_path = app, public', + 'AS $$ BEGIN INSERT INTO jobs VALUES (1); END $$;', + 'CREATE FUNCTION isolated() RETURNS SETOF record', + "LANGUAGE sql SET search_path = ''", + 'AS $$ SELECT * FROM jobs $$;', + 'CREATE FUNCTION defaulted() RETURNS SETOF record', + 'LANGUAGE sql SET search_path TO DEFAULT', + 'AS $$ SELECT * FROM jobs $$;', + 'SELECT * FROM jobs;', + ].join('\n'); + const extracted = extractFromSource('db/schema.sql', source, 'postgres'); + const routines = extracted.nodes.filter((node) => + node.decorators?.includes('postgres:function') || node.decorators?.includes('postgres:procedure') + ); + const byRoutine = new Map(routines.map((routine) => [ + routine.name, + extracted.unresolvedReferences.filter((reference) => reference.fromNodeId === routine.id), + ])); + + expect(byRoutine.get('run_jobs')).toEqual(expect.arrayContaining([ + expect.objectContaining({ + referenceName: 'jobs', + candidates: ['app.jobs', 'public.jobs'], + }), + ])); + expect(byRoutine.get('isolated')).toEqual(expect.arrayContaining([ + expect.objectContaining({ referenceName: 'jobs', candidates: [] }), + ])); + expect(byRoutine.get('defaulted')).toEqual(expect.arrayContaining([ + expect.objectContaining({ referenceName: 'public.jobs' }), + ])); + expect(extracted.unresolvedReferences).toEqual(expect.arrayContaining([ + expect.objectContaining({ + fromNodeId: 'file:db/schema.sql', + referenceName: 'jobs', + }), + ])); + const ambientReference = extracted.unresolvedReferences.find( + (reference) => reference.fromNodeId === 'file:db/schema.sql' && + reference.referenceName === 'jobs' + ); + expect(ambientReference).not.toHaveProperty('candidates'); + }); + + it('resolves ordered candidates with first-existing-schema and ambiguity semantics', () => { + const app = table('app-jobs', 'app.jobs'); + const publicJobs = table('public-jobs', 'public.jobs'); + const outer = table('outer-jobs', 'outer.jobs'); + const candidates = ['app.jobs', 'public.jobs']; + + expect(matchReference(routineRef(candidates), contextFor([app, publicJobs, outer]))) + .toMatchObject({ targetNodeId: app.id }); + expect(matchReference(routineRef(candidates), contextFor([publicJobs, outer]))) + .toMatchObject({ targetNodeId: publicJobs.id }); + + const duplicateApp = table('app-jobs-v2', 'app.jobs', 'app-v2.sql'); + expect(matchReference( + routineRef(candidates), + contextFor([app, duplicateApp, publicJobs, outer]) + )).toBeNull(); + expect(matchReference(routineRef([]), contextFor([outer]))).toBeNull(); + expect(matchReference( + routineRef(['"$user".jobs', 'public.jobs']), + contextFor([publicJobs]) + )).toBeNull(); + }); +}); diff --git a/package.json b/package.json index 7f75b25c3..b0ce5efc0 100644 --- a/package.json +++ b/package.json @@ -19,7 +19,7 @@ "scripts": { "build": "tsc && npm run copy-assets && node -e \"require('fs').chmodSync('dist/bin/codegraph.js', 0o755)\"", "preuninstall": "node dist/bin/uninstall.js", - "copy-assets": "node -e \"const fs=require('fs');fs.mkdirSync('dist/db',{recursive:true});fs.copyFileSync('src/db/schema.sql','dist/db/schema.sql');fs.mkdirSync('dist/extraction/wasm',{recursive:true});fs.readdirSync('src/extraction/wasm').filter(f=>f.endsWith('.wasm')||f==='tree-sitter-postgres.LICENSE').forEach(f=>fs.copyFileSync('src/extraction/wasm/'+f,'dist/extraction/wasm/'+f))\"", + "copy-assets": "node -e \"const fs=require('fs');fs.mkdirSync('dist/db',{recursive:true});fs.copyFileSync('src/db/schema.sql','dist/db/schema.sql');fs.mkdirSync('dist/extraction/wasm',{recursive:true});fs.readdirSync('src/extraction/wasm').filter(f=>f.endsWith('.wasm')||f.endsWith('.LICENSE')).forEach(f=>fs.copyFileSync('src/extraction/wasm/'+f,'dist/extraction/wasm/'+f))\"", "dev": "tsc --watch", "build:kernel": "bash scripts/build-kernel.sh", "cli": "npm run build && node dist/bin/codegraph.js", diff --git a/src/db/queries.ts b/src/db/queries.ts index 66ea04e81..c47805a71 100644 --- a/src/db/queries.ts +++ b/src/db/queries.ts @@ -12,6 +12,7 @@ import { UnresolvedReference, NodeKind, EdgeKind, + ReferenceKind, Language, GraphStats, SearchOptions, @@ -2219,7 +2220,7 @@ export class QueryBuilder { return rows.map((row) => ({ fromNodeId: row.from_node_id, referenceName: row.reference_name, - referenceKind: row.reference_kind as EdgeKind, + referenceKind: row.reference_kind as ReferenceKind, line: row.line, column: row.col, candidates: row.candidates ? safeJsonParse(row.candidates, undefined) : undefined, @@ -2237,7 +2238,7 @@ export class QueryBuilder { return rows.map((row) => ({ fromNodeId: row.from_node_id, referenceName: row.reference_name, - referenceKind: row.reference_kind as EdgeKind, + referenceKind: row.reference_kind as ReferenceKind, line: row.line, column: row.col, candidates: row.candidates ? safeJsonParse(row.candidates, undefined) : undefined, @@ -2285,7 +2286,7 @@ export class QueryBuilder { return rows.map((row) => ({ fromNodeId: row.from_node_id, referenceName: row.reference_name, - referenceKind: row.reference_kind as EdgeKind, + referenceKind: row.reference_kind as ReferenceKind, line: row.line, column: row.col, candidates: row.candidates ? safeJsonParse(row.candidates, undefined) : undefined, @@ -2313,7 +2314,7 @@ export class QueryBuilder { return rows.map((row) => ({ fromNodeId: row.from_node_id, referenceName: row.reference_name, - referenceKind: row.reference_kind as EdgeKind, + referenceKind: row.reference_kind as ReferenceKind, line: row.line, column: row.col, candidates: row.candidates ? safeJsonParse(row.candidates, undefined) : undefined, @@ -2382,7 +2383,7 @@ export class QueryBuilder { return rows.map((row) => ({ fromNodeId: row.from_node_id, referenceName: row.reference_name, - referenceKind: row.reference_kind as EdgeKind, + referenceKind: row.reference_kind as ReferenceKind, line: row.line, column: row.col, candidates: row.candidates ? safeJsonParse(row.candidates, undefined) : undefined, @@ -2564,7 +2565,7 @@ export class QueryBuilder { return rows.map((row) => ({ fromNodeId: row.from_node_id, referenceName: row.reference_name, - referenceKind: row.reference_kind as EdgeKind, + referenceKind: row.reference_kind as ReferenceKind, line: row.line, column: row.col, candidates: row.candidates ? safeJsonParse(row.candidates, undefined) : undefined, diff --git a/src/extraction/extraction-version.ts b/src/extraction/extraction-version.ts index 8ddab13b8..3691e95f0 100644 --- a/src/extraction/extraction-version.ts +++ b/src/extraction/extraction-version.ts @@ -21,4 +21,4 @@ * turns the re-index hint into noise — keep it honest (see CLAUDE.md, "Honesty * in the product is load-bearing"). */ -export const EXTRACTION_VERSION = 26; +export const EXTRACTION_VERSION = 27; diff --git a/src/extraction/grammars.ts b/src/extraction/grammars.ts index dff4fe210..e509b110f 100644 --- a/src/extraction/grammars.ts +++ b/src/extraction/grammars.ts @@ -53,6 +53,15 @@ const WASM_GRAMMAR_FILES: Record = { postgres: 'tree-sitter-postgres.wasm', }; +/** + * PL/pgSQL is an embedded grammar, not a file language: PostgreSQL files use + * the `postgres` grammar and inject routine/DO bodies into this companion. + * Keep it out of Language/EXTENSION_MAP while still preloading it whenever a + * PostgreSQL index is loaded. + */ +const POSTGRES_PLPGSQL_GRAMMAR_KEY = 'plpgsql'; +const POSTGRES_PLPGSQL_WASM_FILE = 'tree-sitter-plpgsql.wasm'; + /** * File extension to Language mapping */ @@ -239,6 +248,9 @@ export function isPlayRoutesFile(filePath: string): boolean { const parserCache = new Map(); const languageCache = new Map(); const unavailableGrammarErrors = new Map(); +let postgresPlpgsqlParser: Parser | null = null; +let postgresPlpgsqlLanguage: WasmLanguage | null = null; +let postgresPlpgsqlUnavailableError: string | null = null; let parserInitialized = false; @@ -294,9 +306,13 @@ export async function initGrammars(): Promise { * The kernel-grammar-parity test asserts this alignment; bump the crate and * the vendored wasm together. * - * PostgreSQL: gmr/tree-sitter-postgres v1.2.4 (BSD-3-Clause), using the - * release's prebuilt ABI-15 tree-sitter-postgres.wasm. The artifact's SHA-256 - * is 084883e58414c407dfac6f37f0facc983afdfe8103e17f5fd2ca138b79a22b92. + * PostgreSQL: gmr/tree-sitter-postgres v1.2.4 (BSD-3-Clause), exact commit + * 9b27ba5c8700f9bf808221a0f6d17fe6515da787. The SQL grammar uses the + * release's prebuilt ABI-15 tree-sitter-postgres.wasm (SHA-256 + * 084883e58414c407dfac6f37f0facc983afdfe8103e17f5fd2ca138b79a22b92). + * The companion PL/pgSQL grammar is built from that tag's checked-in + * plpgsql/src/parser.c + scanner.c with tree-sitter-cli 0.26.7; its WASM + * SHA-256 is 24a4b44b5263cbf78716d5a7301b5ade6f8696dbce08365421e785382427694e. */ const VENDORED_WASM_LANGS: ReadonlySet = new Set([ 'pascal', 'scala', 'lua', 'luau', 'csharp', 'r', 'cfml', 'cfscript', 'cfquery', @@ -359,6 +375,11 @@ function resolveWasmPath(lang: GrammarLanguage): string { : require.resolve(`tree-sitter-wasms/out/${wasmFile}`); } +/** Absolute path of the PostgreSQL companion PL/pgSQL grammar. */ +function resolvePostgresPlpgsqlWasmPath(): string { + return path.join(__dirname, 'wasm', POSTGRES_PLPGSQL_WASM_FILE); +} + /** * Expand an index set's languages to the grammars actually needed to parse it. * SFC languages (svelte/vue/astro) have no grammar of their own — their @@ -400,9 +421,36 @@ export async function readGrammarWasmBytes(languages: Language[]): Promise +): Promise { + if (postgresPlpgsqlLanguage || postgresPlpgsqlUnavailableError) return; + try { + const bytes = wasmBytes?.[POSTGRES_PLPGSQL_GRAMMAR_KEY]; + postgresPlpgsqlLanguage = await WasmLanguage.load( + bytes ?? resolvePostgresPlpgsqlWasmPath() + ); + } catch (error) { + const message = error instanceof Error ? error.message : String(error); + console.warn( + '[CodeGraph] Failed to load PostgreSQL PL/pgSQL companion grammar — ' + + `routine-body parsing will be unavailable: ${message}` + ); + postgresPlpgsqlUnavailableError = message; + } +} + /** * Load grammar WASM files for specific languages only. * Skips languages that are already loaded or have no WASM grammar. @@ -440,6 +488,12 @@ export async function loadGrammarsForLanguages(languages: Language[], wasmBytes? unavailableGrammarErrors.set(lang, message); } } + + // Keep the embedded grammar out of the public Language set, but guarantee + // it is ready before synchronous PostgreSQL extraction begins. + if (languages.includes('postgres')) { + await loadPostgresPlpgsqlGrammar(wasmBytes); + } } /** @@ -478,6 +532,24 @@ export function getParser(language: Language): Parser | null { return parser; } +/** + * Return the preloaded parser for a PL/pgSQL routine/DO body. + * + * This is intentionally separate from getParser(): PL/pgSQL is embedded in a + * PostgreSQL file and must never become an extension-detected file language. + * The accessor is synchronous for use during extraction and safely returns + * null when the companion failed to load. + */ +export function getPostgresPlpgsqlParser(): Parser | null { + if (postgresPlpgsqlParser) return postgresPlpgsqlParser; + if (!postgresPlpgsqlLanguage) return null; + + const parser = new Parser(); + parser.setLanguage(postgresPlpgsqlLanguage); + postgresPlpgsqlParser = parser; + return parser; +} + /** * Detect language from file extension. * @@ -594,6 +666,10 @@ export function resetParser(language: Language): void { old.delete(); parserCache.delete(language); } + if (language === 'postgres' && postgresPlpgsqlParser) { + postgresPlpgsqlParser.delete(); + postgresPlpgsqlParser = null; + } } /** @@ -604,9 +680,14 @@ export function clearParserCache(): void { parser.delete(); } parserCache.clear(); + if (postgresPlpgsqlParser) { + postgresPlpgsqlParser.delete(); + postgresPlpgsqlParser = null; + } // Note: languageCache is NOT cleared — WASM languages persist. // To fully re-init, set parserInitialized = false and call initGrammars() again. unavailableGrammarErrors.clear(); + postgresPlpgsqlUnavailableError = null; } /** diff --git a/src/extraction/languages/postgres.ts b/src/extraction/languages/postgres.ts index 912b1deef..72ec174ea 100644 --- a/src/extraction/languages/postgres.ts +++ b/src/extraction/languages/postgres.ts @@ -1,5 +1,11 @@ import type { Node as SyntaxNode } from 'web-tree-sitter'; import type { Node, NodeKind } from '../../types'; +import { + POSTGRES_DROP_CONSTRAINT_DECORATOR, + POSTGRES_RENAME_CONSTRAINT_DECORATOR, + encodePostgresDropConstraintDescriptor, + encodePostgresRenameConstraintDescriptor, +} from '../../postgres/constraint-mutation'; import { POSTGRES_FOREIGN_KEY_DECORATOR, encodePostgresForeignKeyDescriptor, @@ -10,6 +16,16 @@ import { parsePostgresQualifiedName, serializePostgresQualifiedName, } from '../../postgres/identifiers'; +import { + POSTGRES_SEQUENCE_REFERENCE_KIND, + POSTGRES_TYPE_REFERENCE_KIND, + type PostgresObjectReferenceKind, +} from '../../postgres/reference-intent'; +import { + POSTGRES_DROP_RELATION_DECORATOR, + encodePostgresDropRelationDescriptor, + type PostgresDroppedRelationKind, +} from '../../postgres/relation-lifecycle'; import { analyzePostgresSearchPath, postgresSearchPathAtOffset, @@ -26,6 +42,17 @@ import { type PostgresTableRelationDescriptor, type PostgresTableRelationKind, } from '../../postgres/table-relation'; +import { + POSTGRES_ENUM_VALUE_MUTATION_DECORATOR, + POSTGRES_TYPE_RENAME_DECORATOR, + encodePostgresEnumValueMutationDescriptor, + encodePostgresTypeRenameDescriptor, +} from '../../postgres/type-lifecycle'; +import { + discoverPostgresRoutineBodyReferences, + postgresStaticSequenceLiteral, +} from '../../postgres/routine-body'; +import { getParser, getPostgresPlpgsqlParser } from '../grammars'; import { getNodeText } from '../tree-sitter-helpers'; import type { ExtractorContext, LanguageExtractor } from '../tree-sitter-types'; @@ -38,10 +65,11 @@ import type { ExtractorContext, LanguageExtractor } from '../tree-sitter-types'; * qualified names (`schema.object`). Generic CodeGraph node kinds are reused; * the precise database-object kind is retained as a `postgres:*` decorator. * - * String-literal routine bodies are opaque leaves in the PostgreSQL grammar. - * Top-level SQL and SQL expressions are therefore indexed here, while nested - * SQL/PL/pgSQL extraction requires an injected body grammar and is deliberately - * left for a follow-up. + * Routine bodies are opaque leaves in the outer grammar. Static dollar-quoted + * SQL bodies are reparsed with PostgreSQL; PL/pgSQL and DO blocks are first + * parsed with the pinned companion grammar and only its explicit SQL regions + * are injected back into PostgreSQL. Dynamic EXECUTE remains deliberately + * opaque because indexing must never guess or execute generated source. */ interface SqlName { @@ -50,10 +78,34 @@ interface SqlName { simple: string; } -type ReferenceKind = 'references' | 'calls'; +type ReferenceKind = 'references' | 'calls' | PostgresObjectReferenceKind; const NAME_SEGMENT_TYPES = new Set(['ColId', 'ColLabel', 'type_function_name']); +// GenericType also covers built-ins such as text/jsonb/uuid. Filter the core +// catalog spellings so typed object references stay useful instead of adding a +// failed unresolved row for nearly every column in a schema dump. +const POSTGRES_BUILTIN_TYPES = new Set([ + 'aclitem', 'any', 'anyarray', 'anycompatible', 'anycompatiblearray', 'anycompatiblenonarray', + 'anycompatiblemultirange', 'anycompatiblerange', 'anyelement', 'anyenum', + 'anymultirange', 'anynonarray', 'anyrange', 'bigint', 'bigserial', 'bit', 'bool', + 'boolean', 'box', 'bpchar', 'bytea', 'char', 'character', 'cidr', 'circle', 'cstring', + 'date', 'datemultirange', 'daterange', 'decimal', 'double precision', 'event_trigger', + 'fdw_handler', 'float4', 'float8', 'gtsvector', 'index_am_handler', 'inet', 'int', + 'int2', 'int2vector', 'int4', 'int4multirange', 'int4range', 'int8', 'int8multirange', + 'int8range', 'integer', 'internal', 'interval', 'json', 'jsonb', 'language_handler', + 'line', 'lseg', 'macaddr', 'macaddr8', 'money', 'name', 'numeric', 'nummultirange', + 'numrange', 'oid', 'oidvector', 'opaque', 'path', 'pg_dependencies', 'pg_lsn', + 'pg_mcv_list', 'pg_ndistinct', 'pg_node_tree', 'pg_snapshot', 'point', 'polygon', + 'real', 'record', 'refcursor', 'regclass', 'regcollation', 'regconfig', 'regdictionary', + 'regnamespace', 'regoper', 'regoperator', 'regproc', 'regprocedure', 'regrole', + 'regtype', 'serial', 'serial2', 'serial4', 'serial8', 'smallint', 'smallserial', + 'table_am_handler', 'text', 'tid', 'time', 'timestamp', 'timestamptz', 'timetz', + 'trigger', 'tsm_handler', 'tsmultirange', 'tsquery', 'tsrange', 'tstzmultirange', + 'tstzrange', 'tsvector', 'txid_snapshot', 'unknown', 'uuid', 'varbit', 'varchar', + 'void', 'xid', 'xid8', 'xml', +]); + /** Per-extraction reference de-duplication. `ctx.nodes` is stable for a file. */ const emittedReferenceKeys = new WeakMap>(); const extractionSearchPaths = new WeakMap(); @@ -67,6 +119,338 @@ const extractionTemporaryVisibility = new WeakMap< ExtractionTemporaryVisibilityCache >(); +function postgresDollarTagAt(source: string, offset: number): string | null { + if (source[offset] !== '$') return null; + let end = offset + 1; + if (source[end] === '$') return '$$'; + if (!/[A-Za-z_]/.test(source[end] ?? '')) return null; + end++; + while (/[A-Za-z0-9_]/.test(source[end] ?? '')) end++; + return source[end] === '$' ? source.slice(offset, end + 1) : null; +} + +function isPostgresEscapeStringStart(source: string, quoteOffset: number): boolean { + const prefixOffset = quoteOffset - 1; + const prefix = source[prefixOffset]; + if (prefix !== 'E' && prefix !== 'e') return false; + // E/e is a literal prefix only at a token boundary, not the tail of an + // identifier such as `some' text'`. + return prefixOffset === 0 || !/[A-Za-z0-9_$]/.test(source[prefixOffset - 1] ?? ''); +} + +function postgresCodeMask(source: string): string { + // split('') retains UTF-16 code-unit indexes; a code-point spread would make + // every replacement after an astral character address the wrong position. + const masked = source.split(''); + let single = false; + let singleBackslashEscapes = false; + let double = false; + let dollarTag: string | null = null; + let lineComment = false; + let blockDepth = 0; + for (let index = 0; index < source.length; index++) { + const char = source[index]!; + const next = source[index + 1]; + if (lineComment) { + if (char !== '\n') masked[index] = ' '; + else lineComment = false; + continue; + } + if (blockDepth > 0) { + if (char !== '\n') masked[index] = ' '; + if (char === '/' && next === '*') { + masked[++index] = ' '; + blockDepth++; + } else if (char === '*' && next === '/') { + masked[++index] = ' '; + blockDepth--; + } + continue; + } + if (dollarTag) { + if (char !== '\n') masked[index] = ' '; + if (source.startsWith(dollarTag, index)) { + for (let cursor = index; cursor < index + dollarTag.length; cursor++) masked[cursor] = ' '; + index += dollarTag.length - 1; + dollarTag = null; + } + continue; + } + if (single) { + if (char !== '\n') masked[index] = ' '; + if (char === "'" && next === "'") masked[++index] = ' '; + else if (char === "'") { + single = false; + singleBackslashEscapes = false; + } else if ( + singleBackslashEscapes && char === '\\' && index + 1 < source.length + ) masked[++index] = ' '; + continue; + } + if (double) { + if (char !== '\n') masked[index] = ' '; + if (char === '"' && next === '"') masked[++index] = ' '; + else if (char === '"') double = false; + continue; + } + if (char === '-' && next === '-') { + masked[index] = masked[index + 1] = ' '; + lineComment = true; + index++; + } else if (char === '/' && next === '*') { + masked[index] = masked[index + 1] = ' '; + blockDepth = 1; + index++; + } else if (char === "'") { + masked[index] = ' '; + single = true; + singleBackslashEscapes = isPostgresEscapeStringStart(source, index); + } else if (char === '"') { + masked[index] = ' '; + double = true; + } else if (char === '$') { + const tag = postgresDollarTagAt(source, index); + if (tag) { + for (let cursor = index; cursor < index + tag.length; cursor++) masked[cursor] = ' '; + dollarTag = tag; + index += tag.length - 1; + } + } + } + return masked.join(''); +} + +/** Match COPY's top-level direction without mistaking a query's inner FROM. */ +function isCopyFromStdinStatement(statement: string): boolean { + const copy = /^\s*COPY\b/i.exec(statement); + if (!copy) return false; + let depth = 0; + for (let index = copy[0].length; index < statement.length;) { + const char = statement[index]!; + if (char === '(') { + depth++; + index++; + continue; + } + if (char === ')') { + depth = Math.max(0, depth - 1); + index++; + continue; + } + if (depth === 0 && /[A-Za-z_]/.test(char)) { + const start = index++; + while (/[A-Za-z0-9_$]/.test(statement[index] ?? '')) index++; + const word = statement.slice(start, index).toUpperCase(); + if (word === 'TO') return false; + if (word === 'FROM') { + while (/\s/.test(statement[index] ?? '')) index++; + const source = /^[A-Za-z_][A-Za-z0-9_$]*/.exec(statement.slice(index))?.[0]; + return source?.toUpperCase() === 'STDIN'; + } + continue; + } + index++; + } + return false; +} + +/** + * Offset-preserving PostgreSQL dialect cleanup for constructs intentionally + * outside the core server grammar: + * + * - psql meta-command lines are blanked; + * - psql variables become equivalent parser-safe expressions; + * - a valid CHECK-expression shape that gmr/tree-sitter-postgres currently + * mis-parses receives redundant parentheses in place of existing spaces. + * + * Every replacement is ASCII-for-ASCII and retains every newline, so the AST + * still addresses the original file's byte offsets and source locations. + */ +export function preParsePostgresSource(source: string): string { + const output = source.split(''); + const psqlCopyPayloadStarts: number[] = []; + let single = false; + let singleBackslashEscapes = false; + let double = false; + let dollarTag: string | null = null; + let lineComment = false; + let blockDepth = 0; + let atLineStart = true; + + for (let index = 0; index < source.length; index++) { + if (atLineStart) { + atLineStart = false; + if (!single && !double && !dollarTag && blockDepth === 0 && !lineComment) { + let commandStart = index; + while (source[commandStart] === ' ' || source[commandStart] === '\t') commandStart++; + if (source[commandStart] === '\\') { + const lineEnd = source.indexOf('\n', commandStart); + const end = lineEnd < 0 ? source.length : lineEnd; + const command = source.slice(commandStart, end).replace(/\r$/, ''); + const copyStatement = `${command.slice(1).replace(/;?\s*$/, '')};`; + if (isCopyFromStdinStatement(copyStatement) && lineEnd >= 0) { + psqlCopyPayloadStarts.push(lineEnd + 1); + } + for (let cursor = commandStart; cursor < end; cursor++) output[cursor] = ' '; + index = end - 1; + continue; + } + } + } + + const char = source[index]!; + const next = source[index + 1]; + if (lineComment) { + if (char === '\n') { + lineComment = false; + atLineStart = true; + } + continue; + } + if (blockDepth > 0) { + if (char === '/' && next === '*') { + blockDepth++; + index++; + } else if (char === '*' && next === '/') { + blockDepth--; + index++; + } else if (char === '\n') { + atLineStart = true; + } + continue; + } + if (dollarTag) { + if (source.startsWith(dollarTag, index)) { + index += dollarTag.length - 1; + dollarTag = null; + } else if (char === '\n') { + atLineStart = true; + } + continue; + } + if (single) { + if (char === "'" && next === "'") { + index++; + } else if (char === "'") { + single = false; + singleBackslashEscapes = false; + } else if ( + singleBackslashEscapes && char === '\\' && index + 1 < source.length + ) { + index++; + } else if (char === '\n') { + atLineStart = true; + } + continue; + } + if (double) { + if (char === '"' && next === '"') { + index++; + } else if (char === '"') { + double = false; + } else if (char === '\n') { + atLineStart = true; + } + continue; + } + + if (char === '-' && next === '-') { + lineComment = true; + index++; + } else if (char === '/' && next === '*') { + blockDepth = 1; + index++; + } else if (char === "'") { + single = true; + singleBackslashEscapes = isPostgresEscapeStringStart(source, index); + } else if (char === '"') { + double = true; + } else if (char === '$') { + const tag = postgresDollarTagAt(source, index); + if (tag) { + dollarTag = tag; + index += tag.length - 1; + } + } else if (char === ':' && source[index - 1] !== ':' && (next === "'" || next === '"')) { + // `:'name'` / `:"name"`: removing only the psql interpolation marker + // leaves a valid string literal / quoted identifier of identical length. + output[index] = ' '; + } else if (char === ':' && source[index - 1] !== ':' && /[A-Za-z_]/.test(next ?? '')) { + let end = index + 2; + while (/[A-Za-z0-9_]/.test(source[end] ?? '')) end++; + output[index] = '$'; + output[index + 1] = '1'; + for (let cursor = index + 2; cursor < end; cursor++) output[cursor] = ' '; + index = end - 1; + } else if (char === '\n') { + atLineStart = true; + } + } + + // gmr parses a server COPY statement itself but intentionally does not + // consume psql's following text-format payload. psql's `\copy` uses the same + // payload protocol but normally has no semicolon and its command line was + // blanked above. Only erase a payload when an exact `\.` terminator exists; + // without one, subsequent SQL must remain visible instead of being silently + // treated as data. Every erased byte keeps its original newline/offset. + const blankCopyPayload = (firstDataOffset: number): number | null => { + let lineStart = firstDataOffset; + let terminatorEnd: number | null = null; + while (lineStart < source.length) { + const newline = source.indexOf('\n', lineStart); + const lineEnd = newline < 0 ? source.length : newline; + const line = source.slice(lineStart, lineEnd).replace(/\r$/, ''); + if (line === '\\.') { + terminatorEnd = lineEnd; + break; + } + if (newline < 0) break; + lineStart = newline + 1; + } + if (terminatorEnd === null) return null; + for (let cursor = firstDataOffset; cursor < terminatorEnd; cursor++) { + if (source[cursor] !== '\n') output[cursor] = ' '; + } + const newline = source.indexOf('\n', terminatorEnd); + return newline < 0 ? source.length : newline + 1; + }; + + for (const firstDataOffset of psqlCopyPayloadStarts) { + blankCopyPayload(firstDataOffset); + } + + // Inspect complete semicolon-delimited statements rather than searching for + // the words COPY/FROM/STDIN anywhere. This keeps valid identifiers in e.g. + // `SELECT copy FROM stdin` from erasing every later line in the file. + const preparedCode = postgresCodeMask(output.join('')); + let statementStart = 0; + for (let cursor = 0; cursor < preparedCode.length; cursor++) { + if (preparedCode[cursor] !== ';') continue; + const statement = preparedCode.slice(statementStart, cursor + 1); + const isCopyFromStdin = isCopyFromStdinStatement(statement); + if (isCopyFromStdin) { + const headerLineEnd = source.indexOf('\n', cursor + 1); + const resume = headerLineEnd < 0 ? null : blankCopyPayload(headerLineEnd + 1); + if (resume !== null) { + cursor = resume - 1; + statementStart = resume; + continue; + } + } + statementStart = cursor + 1; + } + + const checkPattern = /(\bCHECK)(\s+)\(([^;\n]*?\bIN\s*\([^()\n]*\))(\s+)=/gi; + const code = postgresCodeMask(output.join('')); + for (let match = checkPattern.exec(code); match; match = checkPattern.exec(code)) { + const afterKeyword = match.index + (match[1]?.length ?? 0); + const beforeEquals = match.index + match[0].length - 1 - (match[4]?.length ?? 0); + output[afterKeyword] = '('; + output[beforeEquals] = ')'; + } + return output.join(''); +} + function children(node: SyntaxNode): SyntaxNode[] { const result: SyntaxNode[] = []; for (let i = 0; i < node.namedChildCount; i++) { @@ -84,6 +468,10 @@ function directChild(node: SyntaxNode, ...types: string[]): SyntaxNode | null { return null; } +function directChildren(node: SyntaxNode, ...types: string[]): SyntaxNode[] { + return children(node).filter((child) => types.includes(child.type)); +} + function firstDescendant(node: SyntaxNode, ...types: string[]): SyntaxNode | null { for (const child of children(node)) { if (types.includes(child.type)) return child; @@ -163,6 +551,13 @@ function sqlNameFromParts(parts: string[]): SqlName { }; } +function isUserDefinedPostgresType(name: SqlName): boolean { + if (name.parts.length > 1) { + return name.parts[0] !== 'pg_catalog' && name.parts[0] !== 'information_schema'; + } + return !POSTGRES_BUILTIN_TYPES.has(name.simple.toLowerCase()); +} + interface NestedSchema { found: boolean; name: SqlName | null; @@ -186,7 +581,7 @@ function nestedSchema(node: SyntaxNode, source: string): NestedSchema { function searchPathState(ctx: ExtractorContext): PostgresSearchPathState { let state = extractionSearchPaths.get(ctx.nodes); if (!state) { - state = analyzePostgresSearchPath(ctx.source); + state = analyzePostgresSearchPath(ctx.source, { copyPayloadsMasked: true }); extractionSearchPaths.set(ctx.nodes, state); } return state; @@ -223,7 +618,8 @@ function temporaryVisibilityState(ctx: ExtractorContext): ExtractionTemporaryVis cached.state = analyzePostgresTemporaryRelationVisibility( ctx.source, cached.candidates, - searchPathState(ctx) + searchPathState(ctx), + true ); } return cached; @@ -349,6 +745,21 @@ function addReference( target: SqlName, kind: ReferenceKind, positionNode: SyntaxNode +): void { + addReferenceAt(ctx, fromNodeId, target, kind, { + startIndex: positionNode.startIndex, + line: positionNode.startPosition.row + 1, + column: positionNode.startPosition.column, + }); +} + +function addReferenceAt( + ctx: ExtractorContext, + fromNodeId: string, + target: SqlName, + kind: ReferenceKind, + position: { startIndex: number; line: number; column: number }, + searchPathCandidates?: readonly string[] ): void { let keys = emittedReferenceKeys.get(ctx.nodes); if (!keys) { @@ -360,27 +771,34 @@ function addReference( // ordinary repeated reads within one segment remain de-duplicated. const activePath = postgresSearchPathAtOffset( searchPathState(ctx), - positionNode.startIndex + position.startIndex ); const temporaryBinding = visibleTemporaryCandidates( ctx, target, - positionNode.startIndex + position.startIndex ).map((candidate) => candidate.id).sort().join('\u001f'); const key = `${fromNodeId}\u0000${kind}\u0000${target.qualified}` + `\u0000${activePath.explicit ? 'explicit' : 'default'}` + `\u0000${activePath.schemas.join('\u001f')}` + + `\u0000routine:${searchPathCandidates === undefined + ? 'ambient' + : searchPathCandidates.join('\u001f')}` + `\u0000temp:${temporaryBinding}`; if (keys.has(key)) return; keys.add(key); - ctx.addUnresolvedReference({ + const reference = { fromNodeId, referenceName: target.qualified, referenceKind: kind, - line: positionNode.startPosition.row + 1, - column: positionNode.startPosition.column, - }); + line: position.line, + column: position.column, + ...(searchPathCandidates === undefined + ? {} + : { candidates: [...searchPathCandidates] }), + }; + ctx.addUnresolvedReference(reference); } function createDatabaseNode( @@ -406,6 +824,13 @@ function createDatabaseNode( }); } +function addDecorators(created: Node | null | undefined, ...decorators: string[]): void { + if (!created) return; + const merged = new Set(created.decorators ?? []); + for (const decorator of decorators) merged.add(decorator); + created.decorators = [...merged]; +} + function walkChildren(node: SyntaxNode, ctx: ExtractorContext): void { for (const child of children(node)) ctx.visitNode(child); } @@ -415,22 +840,35 @@ function createColumn( node: SyntaxNode, nameNode: SyntaxNode, parentQualifiedOverride?: string -): void { +): Node | null { const name = readSqlName(nameNode, ctx.source); - if (!name) return; + if (!name) return null; const parentQualified = parentQualifiedOverride ?? currentScopeQualifiedName(ctx); const qualifiedName = parentQualified ? appendPostgresIdentifier(parentQualified, name.simple) : name.qualified; const idDiscriminator = `${qualifiedName}@${node.startPosition.row + 1}:` + `${node.startPosition.column + 1}`; - ctx.createNode('field', idDiscriminator, node, { + const created = ctx.createNode('field', idDiscriminator, node, { name: name.simple, qualifiedName, signature: compactText(node, ctx.source, 200), decorators: ['postgres:column'], isExported: true, }); + const typeNode = directChild(node, 'Typename'); + const typeName = readSqlName(typeNode, ctx.source); + if (created && typeNode && typeName && isUserDefinedPostgresType(typeName)) { + addReference( + ctx, + created.id, + typeName, + POSTGRES_TYPE_REFERENCE_KIND, + typeNode + ); + } + if (created) createStaticSequenceReferences(node, ctx, created.id); + return created; } function createExplicitColumns(container: SyntaxNode | null, ctx: ExtractorContext): void { @@ -585,6 +1023,30 @@ function routineSignature(node: SyntaxNode, name: SqlName, source: string): stri return `${prefix} ${name.qualified}${argsText}${returnText}`; } +function createRoutineBodyReferences( + node: SyntaxNode, + ctx: ExtractorContext, + ownerId: string +): void { + const postgres = getParser('postgres'); + if (!postgres) return; + const discovery = discoverPostgresRoutineBodyReferences(node, ctx.source, { + postgres, + plpgsql: getPostgresPlpgsqlParser(), + }); + if (discovery.status !== 'analyzed') return; + for (const fact of discovery.facts) { + addReferenceAt( + ctx, + ownerId, + sqlNameFromParts(fact.parts), + fact.kind === 'sequence' ? POSTGRES_SEQUENCE_REFERENCE_KIND : fact.kind, + fact, + fact.searchPathCandidates + ); + } +} + function createRoutine(node: SyntaxNode, ctx: ExtractorContext): boolean { const name = objectName(node, directChild(node, 'func_name'), ctx); if (!name) return true; @@ -598,7 +1060,26 @@ function createRoutine(node: SyntaxNode, ctx: ExtractorContext): boolean { name.qualified, routineSignature(node, name, ctx.source) ); - withCreatedScope(ctx, created, () => walkChildren(node, ctx)); + withCreatedScope(ctx, created, () => { + walkChildren(node, ctx); + if (created) createRoutineBodyReferences(node, ctx, created.id); + }); + return true; +} + +function createDoBlock(node: SyntaxNode, ctx: ExtractorContext): boolean { + const identity = `DO@${node.startPosition.row + 1}:${node.startPosition.column + 1}`; + const created = ctx.createNode('function', identity, node, { + name: 'DO block', + qualifiedName: `${ctx.filePath}::${identity}`, + signature: 'DO block', + decorators: ['postgres:do-block'], + isExported: false, + }); + withCreatedScope(ctx, created, () => { + walkChildren(node, ctx); + if (created) createRoutineBodyReferences(node, ctx, created.id); + }); return true; } @@ -709,6 +1190,7 @@ function createPolicy(node: SyntaxNode, ctx: ExtractorContext): boolean { 'policy', qualifiedName ); + if (node.type === 'AlterPolicyStmt') addDecorators(created, 'postgres:alter-policy'); withCreatedScope(ctx, created, () => { if (created && tableNode && tableName) { addReference(ctx, created.id, tableName, 'references', tableNode); @@ -718,6 +1200,286 @@ function createPolicy(node: SyntaxNode, ctx: ExtractorContext): boolean { return true; } +function renamedName(previous: SqlName, replacement: SqlName): SqlName { + return sqlNameFromParts([...previous.parts.slice(0, -1), replacement.simple]); +} + +function createDrop(node: SyntaxNode, ctx: ExtractorContext): boolean { + const objectType = directChild(node, 'object_type_any_name'); + if (!objectType) return false; + let relationKind: PostgresDroppedRelationKind | null = null; + if (hasDirectChild(objectType, 'kw_table')) { + relationKind = hasDirectChild(objectType, 'kw_foreign') ? 'foreign-table' : 'table'; + } else if (hasDirectChild(objectType, 'kw_view')) { + relationKind = hasDirectChild(objectType, 'kw_materialized') + ? 'materialized-view' + : 'view'; + } + if (!relationKind) return false; + + const objectLabel = relationKind.replace('-', ' ').toUpperCase(); + for (const nameNode of allDescendants(node, 'any_name')) { + const rawName = readSqlName(nameNode, ctx.source); + const name = rawName ? nameInSearchPathSchema(rawName, node, ctx) : null; + if (!name) continue; + const displayName = `DROP ${objectLabel} ${name.qualified}`; + const created = ctx.createNode('constant', `${displayName}@${node.startIndex}`, node, { + name: displayName, + qualifiedName: appendPostgresIdentifier(name.qualified, displayName), + signature: compactText(node, ctx.source), + decorators: [ + POSTGRES_DROP_RELATION_DECORATOR, + encodePostgresDropRelationDescriptor({ + relationName: name.qualified, + relationKind, + }), + ], + isExported: true, + }); + if (created) addReference(ctx, created.id, name, 'references', nameNode); + } + return true; +} + +function createRename(node: SyntaxNode, ctx: ExtractorContext): boolean { + const replacementNodes = directChildren(node, 'name'); + + if (hasDirectChild(node, 'kw_policy')) { + const tableNode = directChild(node, 'qualified_name'); + const rawTable = readSqlName(tableNode, ctx.source); + const table = rawTable ? nameInSearchPathSchema(rawTable, node, ctx) : null; + const replacement = readSqlName(replacementNodes[replacementNodes.length - 1] ?? null, ctx.source); + if (!tableNode || !table || !replacement) return true; + const qualified = appendPostgresIdentifier(table.qualified, replacement.simple); + const created = createDatabaseNode( + ctx, + node, + replacement, + 'constant', + 'policy', + qualified + ); + addDecorators(created, 'postgres:renamed-policy'); + if (created) addReference(ctx, created.id, table, 'references', tableNode); + return true; + } + + const relation = directChild(node, 'relation_expr'); + const tableNode = relation ? firstDescendant(relation, 'qualified_name') : null; + const rawTable = readSqlName(tableNode, ctx.source); + const table = rawTable ? nameInSearchPathSchema(rawTable, node, ctx) : null; + + if (relation && tableNode && table && hasDirectChild(node, 'opt_column')) { + const names = replacementNodes.map((candidate) => readSqlName(candidate, ctx.source)); + const previous = names[0]; + const replacement = names[names.length - 1]; + if (!previous || !replacement) return true; + const qualifiedName = appendPostgresIdentifier(table.qualified, replacement.simple); + const idDiscriminator = `${qualifiedName}@${node.startPosition.row + 1}:` + + `${node.startPosition.column + 1}`; + const created = ctx.createNode('field', idDiscriminator, node, { + name: replacement.simple, + qualifiedName, + signature: compactText(node, ctx.source), + decorators: ['postgres:column', 'postgres:renamed-column'], + isExported: true, + }); + if (created) addReference(ctx, created.id, table, 'references', tableNode); + return true; + } + + if (relation && tableNode && table && hasDirectChild(node, 'kw_constraint')) { + const names = replacementNodes.map((candidate) => readSqlName(candidate, ctx.source)); + const previous = names[0]; + const replacement = names[names.length - 1]; + if (!previous || !replacement) return true; + const qualifiedName = appendPostgresIdentifier(table.qualified, replacement.simple); + const created = createDatabaseNode( + ctx, + node, + replacement, + 'constant', + 'constraint', + qualifiedName + ); + addDecorators( + created, + 'postgres:renamed-constraint', + POSTGRES_RENAME_CONSTRAINT_DECORATOR, + encodePostgresRenameConstraintDescriptor({ + table: table.qualified, + sourceConstraint: previous.simple, + targetConstraint: replacement.simple, + }) + ); + if (created) addReference(ctx, created.id, table, 'references', tableNode); + return true; + } + + if (relation && tableNode && table && hasDirectChild(node, 'kw_table')) { + const replacement = readSqlName(replacementNodes[replacementNodes.length - 1] ?? null, ctx.source); + if (!replacement) return true; + const next = renamedName(table, replacement); + const created = createDatabaseNode(ctx, node, next, 'struct', 'table'); + addDecorators(created, 'postgres:renamed-relation'); + markTemporary(created, isTemporaryRelationName(table)); + if (created) addReference(ctx, created.id, table, 'references', tableNode); + createTableRelationFact( + ctx, + node, + table, + next, + 'rename' as PostgresTableRelationKind, + tableNode, + replacementNodes[replacementNodes.length - 1] ?? node + ); + return true; + } + + const sourceNode = directChild(node, 'qualified_name', 'any_name'); + const rawSource = readSqlName(sourceNode, ctx.source); + const source = rawSource ? nameInSearchPathSchema(rawSource, node, ctx) : null; + const replacement = readSqlName(replacementNodes[replacementNodes.length - 1] ?? null, ctx.source); + if (!sourceNode || !source || !replacement) return true; + const next = renamedName(source, replacement); + + if (hasDirectChild(node, 'kw_view')) { + const objectKind = hasDirectChild(node, 'kw_materialized') + ? 'materialized-view' + : 'view'; + const created = createDatabaseNode(ctx, node, next, 'struct', objectKind); + addDecorators(created, 'postgres:renamed-relation'); + markTemporary(created, isTemporaryRelationName(source)); + if (created) addReference(ctx, created.id, source, 'references', sourceNode); + createTableRelationFact( + ctx, + node, + source, + next, + 'rename' as PostgresTableRelationKind, + sourceNode, + replacementNodes[replacementNodes.length - 1] ?? node + ); + return true; + } + + if (hasDirectChild(node, 'kw_type') && !hasDirectChild(node, 'kw_attribute')) { + const created = createDatabaseNode(ctx, node, next, 'type_alias', 'type'); + addDecorators( + created, + 'postgres:renamed-type', + POSTGRES_TYPE_RENAME_DECORATOR, + encodePostgresTypeRenameDescriptor({ + sourceType: source.qualified, + targetType: next.qualified, + }) + ); + if (created) { + addReference(ctx, created.id, source, POSTGRES_TYPE_REFERENCE_KIND, sourceNode); + } + return true; + } + + const objectKind = hasDirectChild(node, 'kw_index') + ? 'index' + : hasDirectChild(node, 'kw_sequence') + ? 'sequence' + : 'type'; + const kind: NodeKind = objectKind === 'index' + ? 'constant' + : objectKind === 'sequence' + ? 'variable' + : 'type_alias'; + const created = createDatabaseNode(ctx, node, next, kind, objectKind); + addDecorators(created, `postgres:renamed-${objectKind}`); + return true; +} + +function postgresStringLiteral(node: SyntaxNode | null, source: string): string | null { + if (!node) return null; + const raw = getNodeText(node, source); + if (raw.length >= 2 && raw.startsWith("'") && raw.endsWith("'")) { + return raw.slice(1, -1).replace(/''/g, "'"); + } + return raw || null; +} + +function createAlterEnum(node: SyntaxNode, ctx: ExtractorContext): boolean { + const typeNode = directChild(node, 'any_name'); + const rawType = readSqlName(typeNode, ctx.source); + const typeName = rawType ? nameInSearchPathSchema(rawType, node, ctx) : null; + const values = directChildren(node, 'Sconst') + .map((value) => firstDescendant(value, 'string_literal')) + .filter((value): value is SyntaxNode => value !== null); + const renamed = hasDirectChild(node, 'kw_rename'); + const sourceValueNode = renamed ? values[0] ?? null : null; + const valueNode = renamed ? values[values.length - 1] ?? null : values[0] ?? null; + const sourceValue = postgresStringLiteral(sourceValueNode, ctx.source); + const value = postgresStringLiteral(valueNode, ctx.source); + if (!typeName || !valueNode || !value || (renamed && !sourceValue)) return true; + const qualifiedName = appendPostgresIdentifier(typeName.qualified, value); + const idDiscriminator = `${qualifiedName}@${valueNode.startPosition.row + 1}:` + + `${valueNode.startPosition.column + 1}`; + ctx.createNode('enum_member', idDiscriminator, valueNode, { + name: value, + qualifiedName, + signature: compactText(node, ctx.source), + decorators: [ + 'postgres:enum-value', + renamed ? 'postgres:renamed-enum-value' : 'postgres:alter-enum-add-value', + POSTGRES_ENUM_VALUE_MUTATION_DECORATOR, + encodePostgresEnumValueMutationDescriptor(renamed ? { + mutation: 'rename', + enumType: typeName.qualified, + sourceValue: sourceValue!, + targetValue: value, + } : { + mutation: 'add', + enumType: typeName.qualified, + targetValue: value, + }), + ], + isExported: true, + }); + return true; +} + +function createAlterSequence(node: SyntaxNode, ctx: ExtractorContext): boolean { + const sequenceNode = directChild(node, 'qualified_name'); + const rawSequence = readSqlName(sequenceNode, ctx.source); + const sequence = rawSequence ? nameInSearchPathSchema(rawSequence, node, ctx) : null; + const ownerNode = firstDescendant(node, 'any_name'); + const owner = readSqlName(ownerNode, ctx.source); + if (!sequence || !ownerNode || !owner || owner.parts.length < 2) return true; + const table = sqlNameFromParts(owner.parts.slice(0, -1)); + const identity = `OWNED BY ${owner.qualified}`; + const deltaName: SqlName = { + parts: [...sequence.parts, identity], + qualified: appendPostgresIdentifier(sequence.qualified, identity), + simple: sequence.simple, + }; + const created = createDatabaseNode( + ctx, + node, + deltaName, + 'constant', + 'sequence-ownership' + ); + if (created) { + addReference(ctx, created.id, table, 'references', ownerNode); + if (sequenceNode) { + addReference( + ctx, + created.id, + sequence, + POSTGRES_SEQUENCE_REFERENCE_KIND, + sequenceNode + ); + } + } + return true; +} + function createIndex(node: SyntaxNode, ctx: ExtractorContext): boolean { const rawName = readSqlName(directChild(node, 'opt_single_name', 'name'), ctx.source); const relation = directChild(node, 'relation_expr'); @@ -908,6 +1670,158 @@ function createForeignKey(node: SyntaxNode, ctx: ExtractorContext): boolean { return true; } +function createConstraint(node: SyntaxNode, ctx: ExtractorContext): boolean { + const references = directChild(node, 'kw_references'); + if (references && (node.type === 'ColConstraintElem' || hasDirectChild(node, 'kw_foreign'))) { + return createForeignKey(node, ctx); + } + + const constraintKind = hasDirectChild(node, 'kw_primary') + ? 'primary-key' + : hasDirectChild(node, 'kw_unique') + ? 'unique' + : hasDirectChild(node, 'kw_check') + ? 'check' + : null; + if (!constraintKind) { + walkChildren(node, ctx); + return true; + } + + const alter = nearestAncestor(node, 'AlterTableStmt'); + const alterRelation = alter ? directChild(alter, 'relation_expr') : null; + const alterTableNode = alterRelation ? firstDescendant(alterRelation, 'qualified_name') : null; + const rawAlterTable = readSqlName(alterTableNode, ctx.source); + const alterTable = rawAlterTable && alter + ? nameInSearchPathSchema(rawAlterTable, alter, ctx) + : rawAlterTable; + const scope = currentScopeNode(ctx); + const scopeIsTable = scope?.language === 'postgres' && scope.kind === 'struct' && + (scope.decorators?.includes('postgres:table') === true || + scope.decorators?.includes('postgres:foreign-table') === true); + const sourceTable: SqlName | null = alterTable ?? (scopeIsTable && scope ? { + parts: parsePostgresQualifiedName(scope.qualifiedName) ?? [scope.qualifiedName], + qualified: scope.qualifiedName, + simple: scope.name, + } : null); + if (!sourceTable) { + walkChildren(node, ctx); + return true; + } + + const wrapper = nearestAncestor(node, 'TableConstraint', 'ColConstraint'); + const constraintName = readSqlName(wrapper ? directChild(wrapper, 'name') : null, ctx.source); + const columns = node.type === 'ConstraintElem' + ? columnNames(directChild(node, 'columnList'), ctx.source) + : (() => { + const column = nearestAncestor(node, 'columnDef'); + const name = readSqlName(column ? directChild(column, 'ColId') : null, ctx.source); + return name ? [name.simple] : []; + })(); + const label = constraintName?.simple ?? `${constraintKind.toUpperCase()} (${columns.join(', ')})`; + const identity = constraintName?.simple ?? + `${label} @${node.startPosition.row + 1}:${node.startPosition.column + 1}`; + const qualifiedName = appendPostgresIdentifier(sourceTable.qualified, identity); + const idDiscriminator = `${qualifiedName}@${node.startPosition.row + 1}:` + + `${node.startPosition.column + 1}`; + const created = ctx.createNode('constant', idDiscriminator, wrapper ?? node, { + name: label, + qualifiedName, + signature: compactText(wrapper ?? node, ctx.source), + decorators: ['postgres:constraint', `postgres:${constraintKind}`], + isExported: true, + }); + withCreatedScope(ctx, created, () => { + if (created) { + addReference(ctx, created.id, sourceTable, 'references', alterTableNode ?? node); + } + walkChildren(node, ctx); + }); + return true; +} + +function createDropConstraint( + command: SyntaxNode, + ctx: ExtractorContext, + tableName: SqlName, + tableNode: SyntaxNode +): boolean { + if (!hasDirectChild(command, 'kw_drop') || !hasDirectChild(command, 'kw_constraint')) { + return false; + } + const constraintNode = directChild(command, 'name'); + const constraint = readSqlName(constraintNode, ctx.source); + if (!constraintNode || !constraint) return false; + const identity = `DROP CONSTRAINT ${constraint.simple}`; + const qualifiedName = appendPostgresIdentifier(tableName.qualified, identity); + const idDiscriminator = `${qualifiedName}@${command.startPosition.row + 1}:` + + `${command.startPosition.column + 1}`; + const created = ctx.createNode('constant', idDiscriminator, command, { + name: identity, + qualifiedName, + signature: compactText(command, ctx.source), + decorators: [ + POSTGRES_DROP_CONSTRAINT_DECORATOR, + encodePostgresDropConstraintDescriptor({ + table: tableName.qualified, + constraintName: constraint.simple, + }), + ], + isExported: true, + }); + if (created) addReference(ctx, created.id, tableName, 'references', tableNode); + return true; +} + +function createIdentitySequence( + command: SyntaxNode, + ctx: ExtractorContext, + tableName: SqlName, + tableNode: SyntaxNode +): void { + const identity = firstDescendant(command, 'kw_identity'); + if (!identity) return; + const sequenceNode = allDescendants(command, 'any_name') + .find((candidate) => candidate.startIndex > identity.startIndex) ?? null; + const rawSequence = readSqlName(sequenceNode, ctx.source); + const sequence = rawSequence ? nameInSearchPathSchema(rawSequence, command, ctx) : null; + if (!sequenceNode || !sequence) return; + const created = createDatabaseNode(ctx, command, sequence, 'variable', 'sequence'); + addDecorators(created, 'postgres:identity-sequence'); + if (created) addReference(ctx, created.id, tableName, 'references', tableNode); +} + +function createAlterColumnType( + command: SyntaxNode, + ctx: ExtractorContext, + tableName: SqlName, + tableNode: SyntaxNode +): boolean { + const typeNode = directChild(command, 'Typename'); + const typeName = readSqlName(typeNode, ctx.source); + const columnNode = directChild(command, 'ColId'); + const columnName = readSqlName(columnNode, ctx.source); + if (!typeNode || !typeName || !columnName || !isUserDefinedPostgresType(typeName)) return false; + const identity = `ALTER COLUMN ${columnName.simple} TYPE ${typeName.qualified}`; + const qualifiedName = appendPostgresIdentifier(tableName.qualified, identity); + const idDiscriminator = `${qualifiedName}@${command.startPosition.row + 1}:` + + `${command.startPosition.column + 1}`; + const created = ctx.createNode('constant', idDiscriminator, command, { + name: identity, + qualifiedName, + signature: compactText(command, ctx.source), + decorators: ['postgres:alter-table-column-type'], + isExported: true, + }); + withCreatedScope(ctx, created, () => { + if (!created) return; + addReference(ctx, created.id, tableName, 'references', tableNode); + addReference(ctx, created.id, typeName, POSTGRES_TYPE_REFERENCE_KIND, typeNode); + walkChildren(command, ctx); + }); + return true; +} + /** * Model ALTER TABLE ADD COLUMN as a migration delta rather than attaching the * new field to an arbitrary historical CREATE TABLE node. The delta references @@ -988,6 +1902,12 @@ function createAlterTableDeltas(node: SyntaxNode, ctx: ExtractorContext): boolea const commands = directChild(node, 'alter_table_cmds'); if (!commands) return true; for (const command of allDescendants(commands, 'alter_table_cmd')) { + createIdentitySequence(command, ctx, tableName, tableNode); + if (createDropConstraint(command, ctx, tableName, tableNode)) { + walkChildren(command, ctx); + continue; + } + if (createAlterColumnType(command, ctx, tableName, tableNode)) continue; const column = directChild(command, 'columnDef'); const columnNameNode = column ? directChild(column, 'ColId') : null; const columnName = readSqlName(columnNameNode, ctx.source); @@ -1095,6 +2015,41 @@ function emitRelationReference(node: SyntaxNode, ctx: ExtractorContext): boolean return true; } +function createStaticSequenceReferences( + container: SyntaxNode, + ctx: ExtractorContext, + ownerId: string +): void { + const applications = container.type === 'func_application' + ? [container] + : allDescendants(container, 'func_application'); + for (const application of applications) { + const functionName = readSqlName(directChild(application, 'func_name'), ctx.source); + if (!functionName || !['nextval', 'currval', 'setval'].includes(functionName.simple)) continue; + const literal = postgresStaticSequenceLiteral(application); + const rawSequence = postgresStringLiteral(literal, ctx.source); + const parts = rawSequence ? parsePostgresQualifiedName(rawSequence) : null; + if (!literal || !parts || parts.length === 0) continue; + addReference( + ctx, + ownerId, + sqlNameFromParts(parts), + POSTGRES_SEQUENCE_REFERENCE_KIND, + literal + ); + } +} + +function emitTypeReference(node: SyntaxNode, ctx: ExtractorContext): boolean { + if (nearestAncestor(node, 'columnDef', 'alter_table_cmd')) return true; + const name = readSqlName(node, ctx.source); + const ownerId = currentScopeId(ctx); + if (name && ownerId && isUserDefinedPostgresType(name)) { + addReference(ctx, ownerId, name, POSTGRES_TYPE_REFERENCE_KIND, node); + } + return true; +} + function emitRoutineCall(node: SyntaxNode, ctx: ExtractorContext): boolean { const nameNode = directChild(node, 'func_name'); const name = readSqlName(nameNode, ctx.source); @@ -1105,12 +2060,17 @@ function emitRoutineCall(node: SyntaxNode, ctx: ExtractorContext): boolean { // project edges before the resolver can inspect the indexed declarations. if (nameNode && name && fromNodeId) { addReference(ctx, fromNodeId, name, 'calls', nameNode); + if (!nearestAncestor(node, 'columnDef')) { + createStaticSequenceReferences(node, ctx, fromNodeId); + } } walkChildren(node, ctx); return true; } export const postgresExtractor: LanguageExtractor = { + preParse: preParsePostgresSource, + reportParseErrors: true, // All relevant grammar nodes have empty field maps, so visitNode owns the // PostgreSQL dispatch. Empty generic mappings prevent accidental extraction // from wrapper names such as `name` / `ColId`. @@ -1169,6 +2129,9 @@ export const postgresExtractor: LanguageExtractor = { case 'CreateFunctionStmt': return createRoutine(node, ctx); + case 'DoStmt': + return createDoBlock(node, ctx); + case 'CreateSchemaStmt': return createSchema(node, ctx); @@ -1183,14 +2146,27 @@ export const postgresExtractor: LanguageExtractor = { return createTrigger(node, ctx); case 'CreatePolicyStmt': + case 'AlterPolicyStmt': return createPolicy(node, ctx); + case 'RenameStmt': + return createRename(node, ctx); + + case 'DropStmt': + return createDrop(node, ctx); + + case 'AlterEnumStmt': + return createAlterEnum(node, ctx); + case 'IndexStmt': return createIndex(node, ctx); case 'CreateSeqStmt': return createSequence(node, ctx); + case 'AlterSeqStmt': + return createAlterSequence(node, ctx); + case 'CreateExtensionStmt': return createExtension(node, ctx); @@ -1211,7 +2187,10 @@ export const postgresExtractor: LanguageExtractor = { case 'ConstraintElem': case 'ColConstraintElem': - return createForeignKey(node, ctx); + return createConstraint(node, ctx); + + case 'Typename': + return emitTypeReference(node, ctx); case 'relation_expr': case 'insert_target': diff --git a/src/extraction/tree-sitter-types.ts b/src/extraction/tree-sitter-types.ts index 2a02b47b7..0075050f7 100644 --- a/src/extraction/tree-sitter-types.ts +++ b/src/extraction/tree-sitter-types.ts @@ -90,6 +90,15 @@ export interface LanguageExtractor { */ preParse?: (source: string, filePath?: string) => string; + /** + * Record recovered tree-sitter ERROR/MISSING nodes in ExtractionResult while + * still walking the recoverable tree. Most programming-language grammars are + * intentionally tolerant of incomplete editor buffers; strict source formats + * such as migration SQL can opt in so indexing does not silently report a + * malformed file as clean. + */ + reportParseErrors?: boolean; + // --- Node type mappings --- /** Node types that represent functions */ diff --git a/src/extraction/tree-sitter.ts b/src/extraction/tree-sitter.ts index 05b13a9c1..dde021411 100644 --- a/src/extraction/tree-sitter.ts +++ b/src/extraction/tree-sitter.ts @@ -503,6 +503,29 @@ export class TreeSitterExtractor { if (!this.tree) { throw new Error('Parser returned null tree'); } + if (this.extractor?.reportParseErrors && this.tree.rootNode.hasError) { + const findFirstProblem = (node: SyntaxNode): SyntaxNode | null => { + if (node.isError || node.isMissing) return node; + for (let index = 0; index < node.namedChildCount; index++) { + const child = node.namedChild(index); + if (!child) continue; + const problem = findFirstProblem(child); + if (problem) return problem; + } + return null; + }; + const problem = findFirstProblem(this.tree.rootNode); + this.errors.push({ + message: problem?.isMissing + ? `Parser recovered a missing ${problem.type}` + : 'Parser recovered an invalid syntax region', + filePath: this.filePath, + line: (problem?.startPosition.row ?? 0) + 1, + column: problem?.startPosition.column ?? 0, + severity: 'error', + code: 'parse_error', + }); + } // Create file node representing the source file const fileNode: Node = { diff --git a/src/extraction/wasm/tree-sitter-plpgsql.LICENSE b/src/extraction/wasm/tree-sitter-plpgsql.LICENSE new file mode 100644 index 000000000..bb61fcdac --- /dev/null +++ b/src/extraction/wasm/tree-sitter-plpgsql.LICENSE @@ -0,0 +1,25 @@ +Copyright (c) 2026 Gavin M. Roy, AWeber +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + * Neither the name of the copyright holder nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, +INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE +OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/src/extraction/wasm/tree-sitter-plpgsql.wasm b/src/extraction/wasm/tree-sitter-plpgsql.wasm new file mode 100644 index 0000000000000000000000000000000000000000..a34e955b3e973304fa716cfd8cddddb488db968b GIT binary patch literal 137462 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 + decorator.startsWith(POSTGRES_DROP_CONSTRAINT_DATA_PREFIX) + ); + if (!encoded) return null; + try { + const value = JSON.parse(encoded.slice(POSTGRES_DROP_CONSTRAINT_DATA_PREFIX.length)) as + Partial; + if (typeof value.table !== 'string' || typeof value.constraintName !== 'string') return null; + return value as PostgresDropConstraintDescriptor; + } catch { + return null; + } +} + +export function encodePostgresRenameConstraintDescriptor( + descriptor: PostgresRenameConstraintDescriptor +): string { + return `${POSTGRES_RENAME_CONSTRAINT_DATA_PREFIX}${JSON.stringify(descriptor)}`; +} + +export function decodePostgresRenameConstraintDescriptor( + decorators: readonly string[] | undefined +): PostgresRenameConstraintDescriptor | null { + const encoded = decorators?.find((decorator) => + decorator.startsWith(POSTGRES_RENAME_CONSTRAINT_DATA_PREFIX) + ); + if (!encoded) return null; + try { + const value = JSON.parse(encoded.slice(POSTGRES_RENAME_CONSTRAINT_DATA_PREFIX.length)) as + Partial; + if ( + typeof value.table !== 'string' || + typeof value.sourceConstraint !== 'string' || + typeof value.targetConstraint !== 'string' + ) return null; + return value as PostgresRenameConstraintDescriptor; + } catch { + return null; + } +} diff --git a/src/postgres/reference-intent.ts b/src/postgres/reference-intent.ts new file mode 100644 index 000000000..eef01744e --- /dev/null +++ b/src/postgres/reference-intent.ts @@ -0,0 +1,29 @@ +/** + * PostgreSQL-only unresolved-reference intents. + * + * These values are deliberately not graph edge kinds. They carry the object + * class that PostgreSQL resolution must enforce, then materialize as ordinary + * `references` edges after an exact, schema-aware match. Keeping the intent on + * the unresolved row prevents a type or sequence name from falling through to + * the relation matcher (or to a generic fuzzy/framework strategy). + */ +export const POSTGRES_TYPE_REFERENCE_KIND = 'postgres_type' as const; +export const POSTGRES_SEQUENCE_REFERENCE_KIND = 'postgres_sequence' as const; + +export const POSTGRES_OBJECT_REFERENCE_KINDS = [ + POSTGRES_TYPE_REFERENCE_KIND, + POSTGRES_SEQUENCE_REFERENCE_KIND, +] as const; + +export type PostgresObjectReferenceKind = + (typeof POSTGRES_OBJECT_REFERENCE_KINDS)[number]; + +const POSTGRES_OBJECT_REFERENCE_KIND_SET = new Set( + POSTGRES_OBJECT_REFERENCE_KINDS +); + +export function isPostgresObjectReferenceKind( + value: string +): value is PostgresObjectReferenceKind { + return POSTGRES_OBJECT_REFERENCE_KIND_SET.has(value); +} diff --git a/src/postgres/relation-lifecycle.ts b/src/postgres/relation-lifecycle.ts new file mode 100644 index 000000000..e4d00ee66 --- /dev/null +++ b/src/postgres/relation-lifecycle.ts @@ -0,0 +1,43 @@ +/** Ordered PostgreSQL relation lifecycle facts used by migration synthesis. */ + +export const POSTGRES_DROP_RELATION_DECORATOR = 'postgres:drop-relation'; +export const POSTGRES_DROP_RELATION_DATA_PREFIX = 'postgres:drop-relation-data:'; + +export type PostgresDroppedRelationKind = + | 'table' + | 'foreign-table' + | 'view' + | 'materialized-view'; + +export interface PostgresDropRelationDescriptor { + relationName: string; + relationKind: PostgresDroppedRelationKind; +} + +export function encodePostgresDropRelationDescriptor( + descriptor: PostgresDropRelationDescriptor +): string { + return `${POSTGRES_DROP_RELATION_DATA_PREFIX}${JSON.stringify(descriptor)}`; +} + +export function decodePostgresDropRelationDescriptor( + decorators: readonly string[] | undefined +): PostgresDropRelationDescriptor | null { + const encoded = decorators?.find((decorator) => + decorator.startsWith(POSTGRES_DROP_RELATION_DATA_PREFIX) + ); + if (!encoded) return null; + try { + const value = JSON.parse(encoded.slice(POSTGRES_DROP_RELATION_DATA_PREFIX.length)) as + Partial; + if ( + typeof value.relationName !== 'string' || + !['table', 'foreign-table', 'view', 'materialized-view'].includes( + value.relationKind ?? '' + ) + ) return null; + return value as PostgresDropRelationDescriptor; + } catch { + return null; + } +} diff --git a/src/postgres/routine-body.ts b/src/postgres/routine-body.ts new file mode 100644 index 000000000..a882495ae --- /dev/null +++ b/src/postgres/routine-body.ts @@ -0,0 +1,674 @@ +import type { Node as SyntaxNode, Parser } from 'web-tree-sitter'; +import { parsePostgresQualifiedName, serializePostgresQualifiedName } from './identifiers'; +import { + analyzePostgresSearchPath, + parsePostgresSearchPathSetting, + postgresSearchPathAtOffset, + type PostgresSearchPath, +} from './search-path'; + +export type PostgresRoutineBodyLanguage = 'sql' | 'plpgsql'; +export type PostgresRoutineBodyReferenceKind = 'references' | 'calls' | 'sequence'; + +export interface PostgresRoutineBodyReference { + kind: PostgresRoutineBodyReferenceKind; + /** Decoded PostgreSQL identifier segments. */ + parts: string[]; + /** Canonical, quote-preserving qualified name used by resolution. */ + qualifiedName: string; + simpleName: string; + /** + * Ordered, canonical qualified names supplied by a routine-local + * `SET search_path`. Multiple entries are alternatives in PostgreSQL lookup + * order, not independent dependencies. An empty array represents an + * explicitly empty path and must not fall back to the file/session path. + */ + searchPathCandidates?: string[]; + /** Absolute UTF-16 source offset in the containing SQL file. */ + startIndex: number; + /** One-based source line in the containing SQL file. */ + line: number; + /** Zero-based source column in the containing SQL file. */ + column: number; +} + +export type PostgresRoutineBodyStatus = + | 'analyzed' + | 'missing-body' + | 'unsupported-language' + | 'parser-unavailable' + | 'parse-error'; + +export interface PostgresRoutineBodyDiscovery { + status: PostgresRoutineBodyStatus; + language: PostgresRoutineBodyLanguage | null; + bodyStartIndex: number | null; + facts: PostgresRoutineBodyReference[]; + /** Injected fragments that needed conservative PostgreSQL error recovery. */ + recoveredFragments: number; + /** Dynamic EXECUTE regions deliberately excluded from static dependencies. */ + skippedDynamicFragments: number; +} + +export interface PostgresRoutineBodyParsers { + postgres: Parser; + plpgsql: Parser | null; +} + +interface SqlName { + parts: string[]; + qualified: string; + simple: string; +} + +interface StaticBody { + text: string; + startIndex: number; +} + +interface LocalLocation { + startIndex: number; +} + +type LocationMapper = (node: SyntaxNode) => LocalLocation | null; + +const NAME_SEGMENT_TYPES = new Set(['ColId', 'ColLabel', 'type_function_name']); + +const SQL_STATEMENT_TYPES = new Set([ + 'SelectStmt', + 'InsertStmt', + 'UpdateStmt', + 'DeleteStmt', + 'MergeStmt', + 'CallStmt', +]); + +const QUERY_SCOPE_TYPES = new Set([ + 'select_no_parens', + 'InsertStmt', + 'UpdateStmt', + 'DeleteStmt', + 'MergeStmt', +]); + +const QUERY_BOUNDARY_TYPES = new Set([ + ...QUERY_SCOPE_TYPES, + 'SelectStmt', + 'select_with_parens', +]); + +const STATIC_SEQUENCE_LITERAL_WRAPPERS = new Set([ + 'func_arg_expr', + 'a_expr', + 'a_expr_prec', + 'c_expr', + 'AexprConst', + 'Sconst', + 'func_expr', +]); + +function children(node: SyntaxNode): SyntaxNode[] { + const result: SyntaxNode[] = []; + for (let index = 0; index < node.namedChildCount; index++) { + const child = node.namedChild(index); + if (child) result.push(child); + } + return result; +} + +function directChild(node: SyntaxNode, ...types: string[]): SyntaxNode | null { + return children(node).find((child) => types.includes(child.type)) ?? null; +} + +function descendants(node: SyntaxNode, type: string): SyntaxNode[] { + const result: SyntaxNode[] = []; + const visit = (current: SyntaxNode): void => { + for (const child of children(current)) { + if (child.type === type) result.push(child); + visit(child); + } + }; + visit(node); + return result; +} + +function firstDescendant(node: SyntaxNode, type: string): SyntaxNode | null { + for (const child of children(node)) { + if (child.type === type) return child; + const nested = firstDescendant(child, type); + if (nested) return nested; + } + return null; +} + +function hasDirectChild(node: SyntaxNode, type: string): boolean { + return directChild(node, type) !== null; +} + +/** + * Return the first routine argument only when it reduces to a regular string + * literal through syntax-only parentheses and casts. A descendant search is + * unsafe here: dynamic expressions such as `format('%s_seq', tenant)` and + * `'prefix_' || tenant` also contain string literals but do not identify one + * statically knowable sequence. + */ +export function postgresStaticSequenceLiteral( + application: SyntaxNode +): SyntaxNode | null { + const argumentList = directChild(application, 'func_arg_list'); + const firstArgument = argumentList + ? firstDescendant(argumentList, 'func_arg_expr') + : null; + if (!firstArgument) return null; + + const unwrap = (node: SyntaxNode): SyntaxNode | null => { + if (node.type === 'string_literal') return node; + + const nested = children(node); + if ( + node.type === 'func_expr_common_subexpr' && + hasDirectChild(node, 'kw_cast') && + hasDirectChild(node, 'kw_as') && + hasDirectChild(node, 'Typename') + ) { + const expressions = nested.filter((child) => child.type === 'a_expr'); + return expressions.length === 1 ? unwrap(expressions[0]!) : null; + } + + if (node.type === 'a_expr' || node.type === 'a_expr_prec') { + const valueChildren = nested.filter((child) => child.type !== 'Typename'); + const isCast = nested.length === 2 && nested[1]?.type === 'Typename'; + if (isCast && valueChildren.length === 1) return unwrap(valueChildren[0]!); + } + + return STATIC_SEQUENCE_LITERAL_WRAPPERS.has(node.type) && nested.length === 1 + ? unwrap(nested[0]!) + : null; + }; + + return unwrap(firstArgument); +} + +function canonicalSegment(node: SyntaxNode): string { + const raw = node.text.trim(); + if (raw.length >= 2 && raw.startsWith('"') && raw.endsWith('"')) { + return raw.slice(1, -1).replace(/""/g, '"'); + } + return raw.toLowerCase(); +} + +function readSqlName(node: SyntaxNode | null): SqlName | null { + if (!node) return null; + const parts: string[] = []; + + const visit = (current: SyntaxNode): void => { + if (NAME_SEGMENT_TYPES.has(current.type)) { + const part = canonicalSegment(current); + if (part) parts.push(part); + return; + } + if (current.type === 'identifier' || current.type === 'quoted_identifier') { + const part = canonicalSegment(current); + if (part) parts.push(part); + return; + } + for (const child of children(current)) visit(child); + }; + + visit(node); + if (parts.length === 0) return null; + return { + parts, + qualified: serializePostgresQualifiedName(parts), + simple: parts[parts.length - 1]!, + }; +} + +function decodeLanguageOption(option: SyntaxNode): string | null { + const keyword = directChild(option, 'kw_language'); + if (!keyword) return null; + const valueNode = children(option).find((child) => child.startIndex >= keyword.endIndex); + if (!valueNode) return null; + const value = valueNode.text.trim(); + if (value.length >= 2 && value.startsWith("'") && value.endsWith("'")) { + return value.slice(1, -1).replace(/''/g, "'").toLowerCase(); + } + if (value.length >= 2 && value.startsWith('"') && value.endsWith('"')) { + return value.slice(1, -1).replace(/""/g, '"'); + } + return value.toLowerCase(); +} + +function routineLanguage(statement: SyntaxNode): string | null { + const optionType = statement.type === 'DoStmt' ? 'dostmt_opt_item' : 'createfunc_opt_item'; + for (const option of descendants(statement, optionType)) { + const language = decodeLanguageOption(option); + if (language) return language; + } + return statement.type === 'DoStmt' ? 'plpgsql' : null; +} + +/** + * Read CREATE FUNCTION/PROCEDURE's routine-local SET search_path without + * feeding it into the file-level session state machine. PostgreSQL's `FROM + * CURRENT` captures the setting at CREATE time, so that one form deliberately + * reads (but never mutates) the ambient path at the statement offset. + */ +function routineSearchPath( + statement: SyntaxNode, + source: string +): PostgresSearchPath | null { + let configured: PostgresSearchPath | null = null; + let ambient: PostgresSearchPath | null = null; + + for (const clause of descendants(statement, 'FunctionSetResetClause')) { + const rest = directChild(clause, 'set_rest_more'); + const variable = rest ? firstDescendant(rest, 'var_name') : null; + const name = readSqlName(variable); + if (!rest || name?.parts.length !== 1 || name.simple !== 'search_path') continue; + + if (hasDirectChild(rest, 'kw_from') && hasDirectChild(rest, 'kw_current')) { + ambient ??= postgresSearchPathAtOffset( + analyzePostgresSearchPath(source, { copyPayloadsMasked: true }), + statement.startIndex + ); + configured = { + schemas: [...ambient.schemas], + explicit: ambient.explicit, + }; + continue; + } + + const genericSet = firstDescendant(rest, 'generic_set'); + if (!genericSet) continue; + if (hasDirectChild(genericSet, 'kw_default')) { + configured = parsePostgresSearchPathSetting('DEFAULT'); + continue; + } + const values = descendants(genericSet, 'var_value') + .sort((left, right) => left.startIndex - right.startIndex) + .map((value) => source.slice(value.startIndex, value.endIndex)); + if (values.length === 0) continue; + configured = parsePostgresSearchPathSetting(values.join(',')); + } + + return configured; +} + +function applyRoutineSearchPath( + facts: PostgresRoutineBodyReference[], + searchPath: PostgresSearchPath | null +): PostgresRoutineBodyReference[] { + if (!searchPath) return facts; + + return facts.map((fact) => { + // An explicitly schema-qualified body reference always wins over + // search_path, exactly as it does at runtime. + if (fact.parts.length !== 1) return fact; + const candidates = searchPath.schemas.map((schema) => + serializePostgresQualifiedName([schema, ...fact.parts]) + ); + + // A single statically named schema is exact, so expose the qualified fact + // directly. `$user` is role-dependent and remains an ordered candidate + // barrier for the resolver rather than pretending it is a literal schema. + if (candidates.length === 1 && searchPath.schemas[0] !== '$user') { + const parts = [searchPath.schemas[0]!, ...fact.parts]; + return { + ...fact, + parts, + qualifiedName: serializePostgresQualifiedName(parts), + }; + } + + return { ...fact, searchPathCandidates: candidates }; + }); +} + +function staticDollarBody(statement: SyntaxNode, source: string): StaticBody | null { + let bodyLeaves: SyntaxNode[] = []; + if (statement.type === 'CreateFunctionStmt') { + for (const option of descendants(statement, 'createfunc_opt_item')) { + if (!hasDirectChild(option, 'kw_as')) continue; + const funcAs = directChild(option, 'func_as'); + if (funcAs) bodyLeaves.push(...descendants(funcAs, 'dollar_quoted_string')); + } + } else if (statement.type === 'DoStmt') { + for (const option of descendants(statement, 'dostmt_opt_item')) { + if (!hasDirectChild(option, 'kw_language')) { + bodyLeaves.push(...descendants(option, 'dollar_quoted_string')); + } + } + } else { + return null; + } + + if (bodyLeaves.length !== 1) return null; + const leaf = bodyLeaves[0]!; + const raw = source.slice(leaf.startIndex, leaf.endIndex); + const opening = /^\$(?:[A-Za-z_][A-Za-z_0-9]*)?\$/.exec(raw)?.[0]; + if (!opening || raw.length < opening.length * 2 || !raw.endsWith(opening)) return null; + return { + text: raw.slice(opening.length, -opening.length), + startIndex: leaf.startIndex + opening.length, + }; +} + +function nearestSqlStatement(node: SyntaxNode): SyntaxNode | null { + let current: SyntaxNode | null = node.parent; + while (current) { + if (SQL_STATEMENT_TYPES.has(current.type)) return current; + current = current.parent; + } + return null; +} + +function hasErrorAncestorBefore(node: SyntaxNode, boundary: SyntaxNode): boolean { + let current: SyntaxNode | null = node.parent; + while (current && current !== boundary) { + if (current.type === 'ERROR') return true; + current = current.parent; + } + return false; +} + +function ownWithClause(query: SyntaxNode): SyntaxNode | null { + const visit = (node: SyntaxNode): SyntaxNode | null => { + for (const child of children(node)) { + if (child.type === 'with_clause') return child; + if (QUERY_BOUNDARY_TYPES.has(child.type)) continue; + const found = visit(child); + if (found) return found; + } + return null; + }; + return visit(query); +} + +function cteNamesInClause(withClause: SyntaxNode): Set { + const names = new Set(); + const visit = (node: SyntaxNode): void => { + for (const child of children(node)) { + if (child.type === 'common_table_expr') { + const name = readSqlName(directChild(child, 'name')); + if (name) names.add(name.qualified); + continue; + } + visit(child); + } + }; + visit(withClause); + return names; +} + +function cteNamesVisibleFrom(node: SyntaxNode): Set { + const names = new Set(); + let ancestor: SyntaxNode | null = node; + while (ancestor) { + if (QUERY_SCOPE_TYPES.has(ancestor.type)) { + const withClause = ownWithClause(ancestor); + if (withClause) { + for (const name of cteNamesInClause(withClause)) names.add(name); + } + } + ancestor = ancestor.parent; + } + return names; +} + +function lineColumnAt(source: string, startIndex: number): { line: number; column: number } { + let line = 1; + let lineStart = 0; + for (let index = 0; index < startIndex; index++) { + if (source.charCodeAt(index) === 10) { + line++; + lineStart = index + 1; + } + } + return { line, column: startIndex - lineStart }; +} + +function collectPostgresFacts( + root: SyntaxNode, + source: string, + mapLocation: LocationMapper, + recoverFromErrors: boolean +): PostgresRoutineBodyReference[] { + const facts: PostgresRoutineBodyReference[] = []; + + const emitStaticSequence = (application: SyntaxNode): void => { + const functionName = readSqlName(directChild(application, 'func_name')); + if (!functionName || !['nextval', 'currval', 'setval'].includes(functionName.simple)) return; + const literal = postgresStaticSequenceLiteral(application); + if (!literal) return; + const raw = literal.text; + if (raw.length < 2 || !raw.startsWith("'") || !raw.endsWith("'")) return; + const decoded = raw.slice(1, -1).replace(/''/g, "'"); + const parts = parsePostgresQualifiedName(decoded); + const location = mapLocation(literal); + if (!parts || parts.length === 0 || !location) return; + const startIndex = location.startIndex + 1; + const position = lineColumnAt(source, startIndex); + facts.push({ + kind: 'sequence', + parts, + qualifiedName: serializePostgresQualifiedName(parts), + simpleName: parts[parts.length - 1]!, + startIndex, + ...position, + }); + }; + + const emit = ( + node: SyntaxNode, + nameNode: SyntaxNode | null, + kind: PostgresRoutineBodyReferenceKind, + suppressCte: boolean + ): void => { + if (!nameNode) return; + const statement = nearestSqlStatement(node); + if (!statement) return; + if (recoverFromErrors && hasErrorAncestorBefore(node, statement)) return; + const name = readSqlName(nameNode); + if (!name) return; + if ( + suppressCte && + name.parts.length === 1 && + cteNamesVisibleFrom(node).has(name.qualified) + ) return; + const location = mapLocation(nameNode); + if (!location || location.startIndex < 0 || location.startIndex > source.length) return; + const position = lineColumnAt(source, location.startIndex); + facts.push({ + kind, + parts: name.parts, + qualifiedName: name.qualified, + simpleName: name.simple, + startIndex: location.startIndex, + ...position, + }); + }; + + const visit = (node: SyntaxNode): void => { + if (node.type === 'relation_expr') { + emit(node, firstDescendant(node, 'qualified_name'), 'references', true); + } else if (node.type === 'insert_target') { + emit(node, firstDescendant(node, 'qualified_name'), 'references', false); + } else if (node.type === 'func_application') { + emit(node, directChild(node, 'func_name'), 'calls', false); + emitStaticSequence(node); + } + for (const child of children(node)) visit(child); + }; + + visit(root); + return facts; +} + +function isDynamicExpression(expression: SyntaxNode): boolean { + let ancestor: SyntaxNode | null = expression.parent; + while (ancestor && ancestor.type !== 'source_file') { + if (ancestor.type === 'stmt_dynexecute' || ancestor.type === 'for_dynamic') return true; + if ( + (ancestor.type === 'stmt_return' || ancestor.type === 'stmt_open') && + hasDirectChild(ancestor, 'kw_execute') + ) return true; + ancestor = ancestor.parent; + } + return false; +} + +function isDirectSqlExpression(expression: SyntaxNode): boolean { + const parent = expression.parent; + if (!parent) return false; + if (parent.type === 'stmt_execsql' || parent.type === 'for_query') return true; + if (parent.type === 'decl_statement' && hasDirectChild(parent, 'kw_cursor')) return true; + if (parent.type === 'stmt_open' && hasDirectChild(parent, 'kw_for')) return true; + return parent.type === 'stmt_return' && hasDirectChild(parent, 'kw_query'); +} + +function deduplicateFacts( + facts: PostgresRoutineBodyReference[] +): PostgresRoutineBodyReference[] { + const result: PostgresRoutineBodyReference[] = []; + const seen = new Set(); + for (const fact of [...facts].sort((left, right) => left.startIndex - right.startIndex)) { + const key = `${fact.kind}\u0000${fact.qualifiedName}`; + if (seen.has(key)) continue; + seen.add(key); + result.push(fact); + } + return result; +} + +function emptyDiscovery( + status: PostgresRoutineBodyStatus, + language: PostgresRoutineBodyLanguage | null, + bodyStartIndex: number | null = null +): PostgresRoutineBodyDiscovery { + return { + status, + language, + bodyStartIndex, + facts: [], + recoveredFragments: 0, + skippedDynamicFragments: 0, + }; +} + +/** + * Discover static table/routine dependencies inside a PostgreSQL routine or + * anonymous DO body without executing source text. + * + * PL/pgSQL is parsed structurally first so record assignments and dynamic SQL + * cannot bleed into PostgreSQL statement recovery. Each explicit + * `sql_expression` injection region is then parsed independently. Error-free + * expression regions are required; full SQL regions may conservatively retain + * name nodes outside ERROR subtrees so PL/pgSQL's SELECT/RETURNING INTO syntax + * still yields its real table dependencies. + */ +export function discoverPostgresRoutineBodyReferences( + statement: SyntaxNode, + source: string, + parsers: PostgresRoutineBodyParsers +): PostgresRoutineBodyDiscovery { + const rawLanguage = routineLanguage(statement); + const language = rawLanguage === 'sql' || rawLanguage === 'plpgsql' + ? rawLanguage + : null; + if (!language || (statement.type === 'DoStmt' && language !== 'plpgsql')) { + return emptyDiscovery('unsupported-language', language); + } + + const body = staticDollarBody(statement, source); + if (!body) return emptyDiscovery('missing-body', language); + const searchPath = routineSearchPath(statement, source); + + if (language === 'sql') { + const tree = parsers.postgres.parse(body.text); + if (!tree) return emptyDiscovery('parse-error', language, body.startIndex); + try { + if (tree.rootNode.hasError) { + return emptyDiscovery('parse-error', language, body.startIndex); + } + const facts = applyRoutineSearchPath( + collectPostgresFacts( + tree.rootNode, + source, + (node) => ({ startIndex: body.startIndex + node.startIndex }), + false + ), + searchPath + ); + return { + status: 'analyzed', + language, + bodyStartIndex: body.startIndex, + facts: deduplicateFacts(facts), + recoveredFragments: 0, + skippedDynamicFragments: 0, + }; + } finally { + tree.delete(); + } + } + + if (!parsers.plpgsql) { + return emptyDiscovery('parser-unavailable', language, body.startIndex); + } + const plpgsqlTree = parsers.plpgsql.parse(body.text); + if (!plpgsqlTree) return emptyDiscovery('parse-error', language, body.startIndex); + try { + if (plpgsqlTree.rootNode.hasError) { + return emptyDiscovery('parse-error', language, body.startIndex); + } + + const facts: PostgresRoutineBodyReference[] = []; + let recoveredFragments = 0; + let skippedDynamicFragments = 0; + for (const expression of descendants(plpgsqlTree.rootNode, 'sql_expression')) { + if (isDynamicExpression(expression)) { + skippedDynamicFragments++; + continue; + } + + const direct = isDirectSqlExpression(expression); + const prefix = direct ? '' : 'SELECT '; + const suffix = direct ? '' : ';'; + const fragmentTree = parsers.postgres.parse(`${prefix}${expression.text}${suffix}`); + if (!fragmentTree) continue; + try { + const hasErrors = fragmentTree.rootNode.hasError; + // Expression wrappers should be valid PostgreSQL expressions. Reject + // their error recovery wholesale; only full SQL fragments need the + // narrow SELECT/RETURNING INTO recovery used by PL/pgSQL. + if (hasErrors && !direct) continue; + if (hasErrors) recoveredFragments++; + const fragmentStart = body.startIndex + expression.startIndex; + facts.push(...collectPostgresFacts( + fragmentTree.rootNode, + source, + (node) => { + const relative = node.startIndex - prefix.length; + if (relative < 0 || relative >= expression.text.length) return null; + return { startIndex: fragmentStart + relative }; + }, + hasErrors + )); + } finally { + fragmentTree.delete(); + } + } + + return { + status: 'analyzed', + language, + bodyStartIndex: body.startIndex, + facts: deduplicateFacts(applyRoutineSearchPath(facts, searchPath)), + recoveredFragments, + skippedDynamicFragments, + }; + } finally { + plpgsqlTree.delete(); + } +} diff --git a/src/postgres/search-path.ts b/src/postgres/search-path.ts index 2d94fea53..7d6f8579c 100644 --- a/src/postgres/search-path.ts +++ b/src/postgres/search-path.ts @@ -19,6 +19,11 @@ export interface PostgresStatement { endOffset: number; } +export interface PostgresStatementOptions { + /** COPY payloads and their `\.` terminators were already blanked in-place. */ + copyPayloadsMasked?: boolean; +} + interface PostgresSavepoint { name: string; session: PostgresSearchPath; @@ -177,6 +182,18 @@ function parseSetSearchPath(raw: string): PostgresSearchPath { return { schemas, explicit: true }; } +/** + * Parse the value portion of PostgreSQL's `SET search_path TO/=` syntax. + * + * CREATE FUNCTION/PROCEDURE carries the same grammar inside a routine-local + * configuration clause. Exporting this narrow parser keeps quoted identifiers, + * string-literal schema names, empty paths, and DEFAULT behavior identical to + * top-level SET handling without treating the routine option as session state. + */ +export function parsePostgresSearchPathSetting(raw: string): PostgresSearchPath { + return parseSetSearchPath(raw); +} + function parseGucSearchPath(rawLiteral: string): PostgresSearchPath | null { const value = decodeSingleQuoted(rawLiteral) ?? decodeDollarQuoted(rawLiteral); if (value === null) return null; @@ -199,7 +216,10 @@ function parseSetSchema(rawLiteral: string): PostgresSearchPath | null { * spaces, quoted bodies suppress semicolon splitting, and pg_dump COPY payloads * are skipped through their standalone `\.` terminator. */ -export function* postgresTopLevelStatements(source: string): IterableIterator { +export function* postgresTopLevelStatements( + source: string, + options: PostgresStatementOptions = {} +): IterableIterator { const buffer: string[] = []; const MAX_STATEMENT_CHARS = 32_768; let blockDepth = 0; @@ -326,7 +346,8 @@ export function* postgresTopLevelStatements(source: string): IterableIterator schema === b.schemas[index]); } -export function analyzePostgresSearchPath(source: string): PostgresSearchPathState { +export function analyzePostgresSearchPath( + source: string, + options: PostgresStatementOptions = {} +): PostgresSearchPathState { const changes: PostgresSearchPathChange[] = []; const lineStarts = [0]; for (let i = 0; i < source.length; i++) { @@ -358,7 +382,7 @@ export function analyzePostgresSearchPath(source: string): PostgresSearchPathSta if (!samePath(before, after)) changes.push({ offset, ...clonePath(after) }); }; - for (const statement of postgresTopLevelStatements(source)) { + for (const statement of postgresTopLevelStatements(source, options)) { const text = statement.text; const before = clonePath(effective()); const savepoint = /^\s*SAVEPOINT\s+("(?:""|[^"])+"|[A-Za-z_][A-Za-z0-9_$]*)\s*;\s*$/i diff --git a/src/postgres/table-relation.ts b/src/postgres/table-relation.ts index d49f7ed2b..6a3f29e2b 100644 --- a/src/postgres/table-relation.ts +++ b/src/postgres/table-relation.ts @@ -4,6 +4,7 @@ export const POSTGRES_TABLE_RELATION_DECORATOR = 'postgres:table-relation'; export const POSTGRES_TABLE_RELATION_DATA_PREFIX = 'postgres:table-relation-data:'; export type PostgresTableRelationKind = + | 'rename' | 'partition-of' | 'inherits' | 'like' diff --git a/src/postgres/temporary-relations.ts b/src/postgres/temporary-relations.ts index f7e754736..4fbe0c2ba 100644 --- a/src/postgres/temporary-relations.ts +++ b/src/postgres/temporary-relations.ts @@ -230,7 +230,8 @@ function findSavepointIndex(savepoints: TemporarySavepoint[], name: string): num export function analyzePostgresTemporaryRelationVisibility( source: string, nodes: readonly Node[], - positions: PostgresSearchPathState + positions: PostgresSearchPathState, + copyPayloadsMasked = false ): PostgresTemporaryRelationVisibilityState { const declarations: TemporaryDeclaration[] = nodes .filter((node) => node.language === 'postgres' && @@ -288,7 +289,7 @@ export function analyzePostgresTemporaryRelationVisibility( } }; - for (const statement of postgresTopLevelStatements(source)) { + for (const statement of postgresTopLevelStatements(source, { copyPayloadsMasked })) { const text = statement.text; const savepoint = /^\s*SAVEPOINT\s+("(?:""|[^"])+"|[A-Za-z_][A-Za-z0-9_$]*)\s*;\s*$/i .exec(text); diff --git a/src/postgres/type-lifecycle.ts b/src/postgres/type-lifecycle.ts new file mode 100644 index 000000000..142344f3a --- /dev/null +++ b/src/postgres/type-lifecycle.ts @@ -0,0 +1,81 @@ +/** Ordered PostgreSQL type/enum rename facts used by graph synthesis. */ + +export const POSTGRES_TYPE_RENAME_DECORATOR = 'postgres:type-rename'; +export const POSTGRES_TYPE_RENAME_DATA_PREFIX = 'postgres:type-rename-data:'; +export const POSTGRES_ENUM_VALUE_MUTATION_DECORATOR = 'postgres:enum-value-mutation'; +export const POSTGRES_ENUM_VALUE_MUTATION_DATA_PREFIX = + 'postgres:enum-value-mutation-data:'; + +export interface PostgresTypeRenameDescriptor { + sourceType: string; + targetType: string; +} + +export type PostgresEnumValueMutationDescriptor = + | { + mutation: 'add'; + enumType: string; + targetValue: string; + } + | { + mutation: 'rename'; + enumType: string; + sourceValue: string; + targetValue: string; + }; + +export function encodePostgresTypeRenameDescriptor( + descriptor: PostgresTypeRenameDescriptor +): string { + return `${POSTGRES_TYPE_RENAME_DATA_PREFIX}${JSON.stringify(descriptor)}`; +} + +export function decodePostgresTypeRenameDescriptor( + decorators: readonly string[] | undefined +): PostgresTypeRenameDescriptor | null { + const encoded = decorators?.find((decorator) => + decorator.startsWith(POSTGRES_TYPE_RENAME_DATA_PREFIX) + ); + if (!encoded) return null; + try { + const value = JSON.parse(encoded.slice(POSTGRES_TYPE_RENAME_DATA_PREFIX.length)) as + Partial; + if (typeof value.sourceType !== 'string' || typeof value.targetType !== 'string') { + return null; + } + return value as PostgresTypeRenameDescriptor; + } catch { + return null; + } +} + +export function encodePostgresEnumValueMutationDescriptor( + descriptor: PostgresEnumValueMutationDescriptor +): string { + return `${POSTGRES_ENUM_VALUE_MUTATION_DATA_PREFIX}${JSON.stringify(descriptor)}`; +} + +export function decodePostgresEnumValueMutationDescriptor( + decorators: readonly string[] | undefined +): PostgresEnumValueMutationDescriptor | null { + const encoded = decorators?.find((decorator) => + decorator.startsWith(POSTGRES_ENUM_VALUE_MUTATION_DATA_PREFIX) + ); + if (!encoded) return null; + try { + const value = JSON.parse( + encoded.slice(POSTGRES_ENUM_VALUE_MUTATION_DATA_PREFIX.length) + ) as Partial; + if ( + (value.mutation !== 'add' && value.mutation !== 'rename') || + typeof value.enumType !== 'string' || + typeof value.targetValue !== 'string' || + (value.mutation === 'rename' && typeof value.sourceValue !== 'string') + ) { + return null; + } + return value as PostgresEnumValueMutationDescriptor; + } catch { + return null; + } +} diff --git a/src/resolution/index.ts b/src/resolution/index.ts index 46e5f26e6..e1bc8c849 100644 --- a/src/resolution/index.ts +++ b/src/resolution/index.ts @@ -36,6 +36,7 @@ import { loadWorkspacePackages, type WorkspacePackages } from './workspace-packa import { logDebug } from '../errors'; import type { ReExport } from './types'; import { LRUCache } from './lru-cache'; +import { isPostgresObjectReferenceKind } from '../postgres/reference-intent'; /** Node kinds that can declare supertypes (extends/implements). */ const SUPERTYPE_BEARING_KINDS = new Set([ @@ -900,6 +901,11 @@ export class ReferenceResolver { : ref.referenceName; const tPre = this.profileStages ? process.hrtime.bigint() : 0n; const preFilterPass = + // Quoted PostgreSQL identifiers intentionally retain their quotes in the + // reference text while node.name stores the decoded segment. Let the + // schema-aware matcher inspect object intents directly rather than + // dropping e.g. `"Status.Type"` on this generic string pre-filter. + isPostgresObjectReferenceKind(ref.referenceKind) || isNixPathImportRef(ref) || this.hasAnyPossibleMatch(existenceName) || this.matchesAnyImport(ref) || @@ -909,6 +915,14 @@ export class ReferenceResolver { return null; } + // PostgreSQL object intents are internal-only and object-class strict. + // Resolve them directly through the PostgreSQL matcher so a framework or + // import strategy can never bind a type/sequence use to a same-named node + // of another language or object class. + if (isPostgresObjectReferenceKind(ref.referenceKind)) { + return this.gateLanguage(matchReference(ref, this.context), ref); + } + // Function-as-value refs (#756) get a dedicated, strictly-gated path: // import-based resolution first (an imported callback resolves through its // import, the most precise cross-file signal), then matchFunctionRef @@ -1059,13 +1073,14 @@ export class ReferenceResolver { */ createEdges(resolved: ResolvedRef[]): Edge[] { return resolved.map((ref) => { - // `function_ref` (#756) is internal-only: it persists as a `references` - // edge (the registration site depends on the callback), distinguishable - // by metadata.resolvedBy === 'function-ref'. callers/impact already - // traverse `references`, so registration sites surface with no - // graph-layer changes. + // Internal intents persist as `references` edges. The original intent is + // retained in metadata.refKind so removal/re-index resurrection uses the + // same strict matcher rather than degrading to a relation reference. let kind: Edge['kind'] = - ref.original.referenceKind === 'function_ref' ? 'references' : ref.original.referenceKind; + ref.original.referenceKind === 'function_ref' || + isPostgresObjectReferenceKind(ref.original.referenceKind) + ? 'references' + : ref.original.referenceKind; // Promote "extends" to "implements" when a class/struct targets an interface if (kind === 'extends') { diff --git a/src/resolution/name-matcher.ts b/src/resolution/name-matcher.ts index c72d9bcec..ef08e131e 100644 --- a/src/resolution/name-matcher.ts +++ b/src/resolution/name-matcher.ts @@ -5,6 +5,7 @@ */ import { Language, Node } from '../types'; +import { preParsePostgresSource } from '../extraction/languages/postgres'; import { analyzePostgresSearchPath, postgresOffsetAtPosition, @@ -21,6 +22,12 @@ import { postgresTemporaryRelationVisibleAt, type PostgresTemporaryRelationVisibilityState, } from '../postgres/temporary-relations'; +import { + POSTGRES_SEQUENCE_REFERENCE_KIND, + POSTGRES_TYPE_REFERENCE_KIND, +} from '../postgres/reference-intent'; +import { POSTGRES_DROP_RELATION_DECORATOR } from '../postgres/relation-lifecycle'; +import { latestPostgresMigrationNodeBefore } from './postgres-rename-timeline'; import { UnresolvedRef, ResolvedRef, ResolutionContext } from './types'; /** @@ -371,11 +378,15 @@ export function matchFunctionRef( * - one same-file candidate wins, otherwise the project-wide candidate must * be unique; * - callable references target decorated routines only; relation references - * target relation-like (`struct`) nodes only. + * target relation-like (`struct`) nodes only; + * - internal type/sequence intents target only their decorated PostgreSQL + * object class and later materialize as ordinary `references` edges. * * Unqualified references honor top-level SET/RESET search_path state (with - * PostgreSQL's default public fallback). Duplicate historical definitions are - * still left unresolved until an ordered-migration model can distinguish them. + * PostgreSQL's default public fallback); routine-local SET search_path is + * carried on that routine's references as an ordered override. Duplicate + * historical definitions are still left unresolved until an ordered-migration + * model can distinguish them. */ const POSTGRES_SEARCH_PATH_CACHE = new WeakMap< ResolutionContext, @@ -398,7 +409,14 @@ function postgresSearchPathState( const cached = byFile.get(filePath); if (cached) return cached; - const state = analyzePostgresSearchPath(context.readFile(filePath) ?? ''); + // Resolution must analyze the exact offset-preserving source seen by the + // PostgreSQL parser. Raw psql commands and COPY FROM STDIN payloads are not + // SQL session statements and must not change search_path here after the + // extractor deliberately blanked them. + const state = analyzePostgresSearchPath( + preParsePostgresSource(context.readFile(filePath) ?? ''), + { copyPayloadsMasked: true } + ); byFile.set(filePath, state); return state; } @@ -417,9 +435,10 @@ function postgresTemporaryVisibilityState( if (cached) return cached; const state = analyzePostgresTemporaryRelationVisibility( - context.readFile(filePath) ?? '', + preParsePostgresSource(context.readFile(filePath) ?? ''), context.getNodesInFile(filePath), - positions + positions, + true ); byFile.set(filePath, state); return state; @@ -456,6 +475,20 @@ export function matchPostgresReference( node.decorators?.includes('postgres:procedure') === true ); } + if (ref.referenceKind === POSTGRES_TYPE_REFERENCE_KIND) { + return ( + node.kind === 'enum' && node.decorators?.includes('postgres:enum') === true + ) || ( + node.kind === 'type_alias' && ( + node.decorators?.includes('postgres:type') === true || + node.decorators?.includes('postgres:domain') === true + ) + ); + } + if (ref.referenceKind === POSTGRES_SEQUENCE_REFERENCE_KIND) { + return node.kind === 'variable' && + node.decorators?.includes('postgres:sequence') === true; + } return node.kind === 'struct'; }; @@ -464,10 +497,23 @@ export function matchPostgresReference( const isQualified = ref.referenceName.includes('::') || isPostgresQualifiedName(ref.referenceName); const pick = (candidates: Node[]): Node | undefined => { + // DROP is itself a lifecycle boundary. With several historical definitions + // of the same relation, its target is the latest declaration before the + // statement in this migration stream, never a declaration later in the + // same file. Apply chronology before the normal same-file preference. + const source = context.getNodeById?.(ref.fromNodeId); + if (source?.decorators?.includes(POSTGRES_DROP_RELATION_DECORATOR) === true) { + return latestPostgresMigrationNodeBefore(candidates, { + filePath: ref.filePath, + line: ref.line, + column: ref.column, + }) ?? undefined; + } + const sameFile = candidates.filter((node) => node.filePath === ref.filePath); if (sameFile.length === 1) return sameFile[0]; - if (sameFile.length > 1) return undefined; - return candidates.length === 1 ? candidates[0] : undefined; + if (sameFile.length === 0 && candidates.length === 1) return candidates[0]; + return undefined; }; let target: Node | undefined; @@ -475,7 +521,6 @@ export function matchPostgresReference( const candidates = context.getNodesByQualifiedName(ref.referenceName).filter(eligible); target = pick(candidates); } else { - const searchPath = sharedPostgresSearchPathAtOffset(positions, refOffset); let foundInSearchPath = false; if (!isCallable) { const temporaryName = qualifyPostgresName('pg_temp', ref.referenceName); @@ -487,29 +532,53 @@ export function matchPostgresReference( target = pick(temporaryCandidates); } } - for (const schema of searchPath.schemas) { - if (foundInSearchPath) break; - // The runtime role behind $user is unknowable from source. It shadows - // later schemas when present, so choosing a later candidate would invent - // certainty; leave the reference unresolved instead. - if (schema === '$user') { + + if (ref.candidates !== undefined) { + // A routine-local SET search_path is carried as ordered canonical + // qualified candidates. It must override (not mutate) the ambient file + // path, and the first schema containing a name shadows every later one. + // An empty list is an explicitly empty path. `$user` is a role-dependent + // barrier: once reached, choosing a later schema would invent certainty. + for (const qualified of ref.candidates) { + if (foundInSearchPath) break; + if (parsePostgresQualifiedName(qualified)?.[0] === '$user') { + foundInSearchPath = true; + break; + } + const schemaCandidates = context + .getNodesByQualifiedName(qualified) + .filter(eligible); + if (schemaCandidates.length === 0) continue; foundInSearchPath = true; + target = pick(schemaCandidates); + break; + } + } else { + const searchPath = sharedPostgresSearchPathAtOffset(positions, refOffset); + for (const schema of searchPath.schemas) { + if (foundInSearchPath) break; + // The runtime role behind $user is unknowable from source. It shadows + // later schemas when present, so choosing a later candidate would invent + // certainty; leave the reference unresolved instead. + if (schema === '$user') { + foundInSearchPath = true; + break; + } + const qualified = qualifyPostgresName(schema, ref.referenceName); + const schemaCandidates = [ + ...(qualified ? context.getNodesByQualifiedName(qualified) : []), + ...context.getNodesByQualifiedName(`${schema}::${ref.referenceName}`), + ].filter(eligible); + if (schemaCandidates.length === 0) continue; + // The first schema containing the name shadows every later schema. If + // that schema has duplicate historical definitions, preserve ambiguity. + foundInSearchPath = true; + target = pick(schemaCandidates); break; } - const qualified = qualifyPostgresName(schema, ref.referenceName); - const schemaCandidates = [ - ...(qualified ? context.getNodesByQualifiedName(qualified) : []), - ...context.getNodesByQualifiedName(`${schema}::${ref.referenceName}`), - ].filter(eligible); - if (schemaCandidates.length === 0) continue; - // The first schema containing the name shadows every later schema. If - // that schema has duplicate historical definitions, preserve ambiguity. - foundInSearchPath = true; - target = pick(schemaCandidates); - break; } - if (!target && !foundInSearchPath) { + if (!target && !foundInSearchPath && ref.candidates === undefined) { const candidates = context.getNodesByName(referenceSimple).filter(eligible); // Never jump to a qualified schema outside the active path. A uniquely // unqualified declaration is retained for extractor backward diff --git a/src/resolution/postgres-enum-lifecycle.ts b/src/resolution/postgres-enum-lifecycle.ts new file mode 100644 index 000000000..717fb25a4 --- /dev/null +++ b/src/resolution/postgres-enum-lifecycle.ts @@ -0,0 +1,239 @@ +import type { QueryBuilder } from '../db/queries'; +import { + decodePostgresEnumValueMutationDescriptor, + decodePostgresTypeRenameDescriptor, + type PostgresEnumValueMutationDescriptor, + type PostgresTypeRenameDescriptor, +} from '../postgres/type-lifecycle'; +import type { Edge, Node } from '../types'; +import { + comparePostgresMigrationPosition, + type PostgresMigrationPosition, +} from './postgres-rename-timeline'; + +const POSTGRES_STRUCTURE_SYNTHESIZER = 'postgres-structure'; + +interface EnumState { + parent: Node; + members: Map; +} + +type EnumLifecycleEvent = + | { + kind: 'enum-declaration'; + node: Node; + position: PostgresMigrationPosition; + } + | { + kind: 'type-declaration'; + node: Node; + position: PostgresMigrationPosition; + } + | { + kind: 'type-rename'; + node: Node; + descriptor: PostgresTypeRenameDescriptor; + position: PostgresMigrationPosition; + } + | { + kind: 'value-mutation'; + node: Node; + descriptor: PostgresEnumValueMutationDescriptor; + position: PostgresMigrationPosition; + }; + +function migrationStream(filePath: string): string { + const normalized = filePath.replace(/\\/g, '/'); + const separator = normalized.lastIndexOf('/'); + return separator < 0 ? '' : normalized.slice(0, separator); +} + +function position(node: Node): PostgresMigrationPosition { + return { + filePath: node.filePath, + line: node.startLine, + column: node.startColumn, + }; +} + +function eventRank(event: EnumLifecycleEvent): number { + if (event.kind === 'enum-declaration' || event.kind === 'type-declaration') return 0; + if (event.kind === 'value-mutation') return 1; + return 2; +} + +function nativeEnumMembers(queries: QueryBuilder, parent: Node): Map { + const members = new Map(); + for (const edge of queries.getOutgoingEdges(parent.id, ['contains'])) { + if (edge.metadata?.synthesizedBy === POSTGRES_STRUCTURE_SYNTHESIZER) continue; + const member = queries.getNodeById(edge.target); + if ( + member?.language !== 'postgres' || + member.kind !== 'enum_member' || + member.decorators?.includes('postgres:enum-value') !== true + ) continue; + members.set(member.name, member); + } + return members; +} + +function isEnumDeclaration(node: Node): boolean { + return node.language === 'postgres' && node.kind === 'enum' && + node.decorators?.includes('postgres:enum') === true; +} + +function isPlainTypeDeclaration(node: Node): boolean { + return node.language === 'postgres' && node.kind === 'type_alias' && + node.decorators?.includes('postgres:type') === true && + decodePostgresTypeRenameDescriptor(node.decorators) === null; +} + +/** + * Carry effective enum identity and membership across ordered ALTER TYPE + * renames without classifying every renamed PostgreSQL type as an enum during + * extraction. A rename becomes enum-specific only when its latest live source + * in the same migration stream is an enum state. + */ +export function postgresEnumLifecycleEdges(queries: QueryBuilder): Edge[] { + const byStream = new Map(); + const append = (node: Node, event: EnumLifecycleEvent): void => { + const stream = migrationStream(node.filePath); + const events = byStream.get(stream); + if (events) events.push(event); + else byStream.set(stream, [event]); + }; + + for (const node of queries.iterateNodesByLanguage('postgres')) { + const typeRename = decodePostgresTypeRenameDescriptor(node.decorators); + if (typeRename) { + append(node, { kind: 'type-rename', node, descriptor: typeRename, position: position(node) }); + continue; + } + const valueMutation = decodePostgresEnumValueMutationDescriptor(node.decorators); + if (valueMutation) { + append(node, { + kind: 'value-mutation', + node, + descriptor: valueMutation, + position: position(node), + }); + continue; + } + if (isEnumDeclaration(node)) { + append(node, { kind: 'enum-declaration', node, position: position(node) }); + } else if (isPlainTypeDeclaration(node)) { + append(node, { kind: 'type-declaration', node, position: position(node) }); + } + } + + const edges = new Map(); + const addEdge = (edge: Edge): void => { + edges.set(`${edge.source}\u0000${edge.target}\u0000${edge.kind}`, edge); + }; + const snapshotAlias = (state: EnumState): void => { + if (!decodePostgresTypeRenameDescriptor(state.parent.decorators)) return; + for (const [label, member] of state.members) { + addEdge({ + source: state.parent.id, + target: member.id, + kind: 'contains', + line: member.startLine, + column: member.startColumn, + provenance: 'tree-sitter', + metadata: { + synthesizedBy: POSTGRES_STRUCTURE_SYNTHESIZER, + postgresRelation: 'enum-effective-containment', + effectiveLabel: label, + }, + }); + } + }; + + for (const events of byStream.values()) { + events.sort((left, right) => + comparePostgresMigrationPosition(left.position, right.position) || + eventRank(left) - eventRank(right) || + (left.node.id < right.node.id ? -1 : left.node.id > right.node.id ? 1 : 0) + ); + const states = new Map(); + + for (const event of events) { + if (event.kind === 'enum-declaration') { + states.set(event.node.qualifiedName, { + parent: event.node, + members: nativeEnumMembers(queries, event.node), + }); + continue; + } + if (event.kind === 'type-declaration') { + // A later non-enum declaration with the same name invalidates an older + // enum candidate; do not infer enum identity from stale history. + states.delete(event.node.qualifiedName); + continue; + } + if (event.kind === 'value-mutation') { + const state = states.get(event.descriptor.enumType); + if (!state) continue; + if (event.descriptor.mutation === 'add') { + if (!state.members.has(event.descriptor.targetValue)) { + state.members.set(event.descriptor.targetValue, event.node); + } + } else { + const sourceMember = state.members.get(event.descriptor.sourceValue); + if (sourceMember) { + // Native CREATE TYPE containment is extracted source history and is + // deliberately not deleted by this cross-file synthesizer. Record + // the state transition explicitly so callers can distinguish the + // old, still-queryable label from the effective replacement. + addEdge({ + source: sourceMember.id, + target: event.node.id, + kind: 'references', + line: event.node.startLine, + column: event.node.startColumn, + provenance: 'tree-sitter', + metadata: { + synthesizedBy: POSTGRES_STRUCTURE_SYNTHESIZER, + postgresRelation: 'enum-value-rename', + enumType: event.descriptor.enumType, + sourceValue: event.descriptor.sourceValue, + targetValue: event.descriptor.targetValue, + }, + }); + } + state.members.delete(event.descriptor.sourceValue); + state.members.set(event.descriptor.targetValue, event.node); + } + continue; + } + + const source = states.get(event.descriptor.sourceType); + if (!source) continue; + snapshotAlias(source); + states.delete(event.descriptor.sourceType); + const target: EnumState = { + parent: event.node, + members: new Map(source.members), + }; + states.set(event.descriptor.targetType, target); + addEdge({ + source: source.parent.id, + target: event.node.id, + kind: 'references', + line: event.node.startLine, + column: event.node.startColumn, + provenance: 'tree-sitter', + metadata: { + synthesizedBy: POSTGRES_STRUCTURE_SYNTHESIZER, + postgresRelation: 'enum-rename', + sourceType: event.descriptor.sourceType, + targetType: event.descriptor.targetType, + }, + }); + } + + for (const state of states.values()) snapshotAlias(state); + } + + return [...edges.values()]; +} diff --git a/src/resolution/postgres-foreign-key-synthesizer.ts b/src/resolution/postgres-foreign-key-synthesizer.ts index e74981cfd..a0c01c82a 100644 --- a/src/resolution/postgres-foreign-key-synthesizer.ts +++ b/src/resolution/postgres-foreign-key-synthesizer.ts @@ -6,8 +6,27 @@ import { decodePostgresForeignKeyDescriptor, type PostgresForeignKeyDescriptor, } from '../postgres/foreign-key'; -import { isPostgresQualifiedName } from '../postgres/identifiers'; +import { + POSTGRES_DROP_CONSTRAINT_DECORATOR, + POSTGRES_RENAME_CONSTRAINT_DECORATOR, + decodePostgresDropConstraintDescriptor, + decodePostgresRenameConstraintDescriptor, +} from '../postgres/constraint-mutation'; +import { + POSTGRES_TABLE_RELATION_DECORATOR, + decodePostgresTableRelationDescriptor, +} from '../postgres/table-relation'; +import { POSTGRES_DROP_RELATION_DECORATOR } from '../postgres/relation-lifecycle'; import type { MaybeYield } from './cooperative-yield'; +import { PostgresRelationLifecycle } from './postgres-relation-lifecycle'; +import { + PostgresTableRenameTimeline, + comparePostgresMigrationPosition, + isPostgresMigrationPositionLater, + isPostgresTable, + type PostgresMigrationPosition, + type PostgresResolvedTableEndpoint, +} from './postgres-rename-timeline'; export const POSTGRES_FOREIGN_KEY_SYNTHESIZER = 'postgres-foreign-key'; export const POSTGRES_FOREIGN_KEY_FINGERPRINT_METADATA = @@ -16,6 +35,8 @@ export const POSTGRES_FOREIGN_KEY_FINGERPRINT_METADATA = interface ConstraintFact extends PostgresForeignKeyDescriptor { filePath: string; line: number; + column: number; + originalConstraintName?: string; } interface ForeignKeyGroup { @@ -25,36 +46,103 @@ interface ForeignKeyGroup { line: number; } -function isTable(node: Node | null): node is Node { - return node?.language === 'postgres' && node.kind === 'struct' && ( - node.decorators?.includes('postgres:table') === true || - node.decorators?.includes('postgres:foreign-table') === true +interface DropConstraintEvent extends PostgresMigrationPosition { + nodeId: string; + table: string; + constraintName: string; +} + +interface RenameConstraintEvent extends PostgresMigrationPosition { + nodeId: string; + table: string; + sourceConstraint: string; + targetConstraint: string; +} + +function collectDropConstraintEvents(queries: QueryBuilder): DropConstraintEvent[] { + const events: DropConstraintEvent[] = []; + for (const fact of queries.iterateNodesByLanguageWithDecorator( + 'postgres', + POSTGRES_DROP_CONSTRAINT_DECORATOR + )) { + const descriptor = decodePostgresDropConstraintDescriptor(fact.decorators); + if (!descriptor) continue; + events.push({ + ...descriptor, + nodeId: fact.id, + filePath: fact.filePath, + line: fact.startLine, + column: fact.startColumn, + }); + } + return events.sort((left, right) => + comparePostgresMigrationPosition(left, right) || + (left.nodeId < right.nodeId ? -1 : left.nodeId > right.nodeId ? 1 : 0) ); } -interface ResolvedEndpoint { - node: Node; - refName: string | undefined; -} - -function resolvedEndpoint( - endpoints: ResolvedEndpoint[], - name: string -): Node | null { - // `refName` preserves which of the FK fact's two references produced an - // edge. Node-name matching alone cannot distinguish `audit.users` (source) - // from an unqualified `users` target resolved through search_path. - let matches = endpoints - .filter((endpoint) => endpoint.refName === name) - .map((endpoint) => endpoint.node); - if (matches.length === 0) { - const qualified = isPostgresQualifiedName(name); - matches = endpoints - .map((endpoint) => endpoint.node) - .filter((node) => qualified ? node.qualifiedName === name : node.name === name); +function collectRenameConstraintEvents(queries: QueryBuilder): RenameConstraintEvent[] { + const events: RenameConstraintEvent[] = []; + for (const fact of queries.iterateNodesByLanguageWithDecorator( + 'postgres', + POSTGRES_RENAME_CONSTRAINT_DECORATOR + )) { + const descriptor = decodePostgresRenameConstraintDescriptor(fact.decorators); + if (!descriptor) continue; + events.push({ + ...descriptor, + nodeId: fact.id, + filePath: fact.filePath, + line: fact.startLine, + column: fact.startColumn, + }); } - const unique = new Map(matches.map((node) => [node.id, node])); - return unique.size === 1 ? unique.values().next().value ?? null : null; + return events.sort((left, right) => + comparePostgresMigrationPosition(left, right) || + (left.nodeId < right.nodeId ? -1 : left.nodeId > right.nodeId ? 1 : 0) + ); +} + +function canonicalConstraintName( + constraintName: string, + table: string, + position: PostgresMigrationPosition, + renames: PostgresTableRenameTimeline, + constraintRenames: readonly RenameConstraintEvent[], + through?: PostgresMigrationPosition +): string { + const finalTable = renames.canonicalName(table, position); + let current = constraintName; + for (const event of constraintRenames) { + if (!isPostgresMigrationPositionLater(event, position)) continue; + if (through && isPostgresMigrationPositionLater(event, through)) continue; + if (renames.canonicalName(event.table, event) !== finalTable) continue; + if (event.sourceConstraint === current) current = event.targetConstraint; + } + return current; +} + +function isSuppressedByLaterDrop( + descriptor: PostgresForeignKeyDescriptor, + position: PostgresMigrationPosition, + drops: readonly DropConstraintEvent[], + renames: PostgresTableRenameTimeline, + constraintRenames: readonly RenameConstraintEvent[] +): boolean { + if (!descriptor.constraintName) return false; + const finalSourceTable = renames.canonicalName(descriptor.sourceTable, position); + return drops.some((drop) => + isPostgresMigrationPositionLater(drop, position) && + renames.canonicalName(drop.table, drop) === finalSourceTable && + drop.constraintName === canonicalConstraintName( + descriptor.constraintName!, + descriptor.sourceTable, + position, + renames, + constraintRenames, + drop + ) + ); } /** @@ -65,28 +153,65 @@ function resolvedEndpoint( function collectForeignKey( grouped: Map, queries: QueryBuilder, - foreignKey: Node + foreignKey: Node, + renames: PostgresTableRenameTimeline, + lifecycle: PostgresRelationLifecycle, + drops: readonly DropConstraintEvent[], + constraintRenames: readonly RenameConstraintEvent[] ): void { if (!foreignKey.decorators?.includes(POSTGRES_FOREIGN_KEY_DECORATOR)) return; const descriptor = decodePostgresForeignKeyDescriptor(foreignKey.decorators); if (!descriptor) return; + const position: PostgresMigrationPosition = { + filePath: foreignKey.filePath, + line: foreignKey.startLine, + column: foreignKey.startColumn, + }; + if ( + lifecycle.isDroppedAfter(descriptor.sourceTable, position) || + lifecycle.isDroppedAfter(descriptor.targetTable, position) + ) return; + if (isSuppressedByLaterDrop( + descriptor, + position, + drops, + renames, + constraintRenames + )) return; + const endpoints = queries .getOutgoingEdges(foreignKey.id, ['references']) .map((edge) => ({ node: queries.getNodeById(edge.target), refName: typeof edge.metadata?.refName === 'string' ? edge.metadata.refName : undefined, })) - .filter((endpoint): endpoint is ResolvedEndpoint => isTable(endpoint.node)); - const source = resolvedEndpoint(endpoints, descriptor.sourceTable); - const target = resolvedEndpoint(endpoints, descriptor.targetTable); + .filter((endpoint): endpoint is PostgresResolvedTableEndpoint => + isPostgresTable(endpoint.node) + ); + const source = lifecycle.canonicalTableEndpoint(endpoints, descriptor.sourceTable, position); + const target = lifecycle.canonicalTableEndpoint(endpoints, descriptor.targetTable, position); if (!source || !target) return; const key = `${source.id}\u0000${target.id}`; + const finalConstraintName = descriptor.constraintName + ? canonicalConstraintName( + descriptor.constraintName, + descriptor.sourceTable, + position, + renames, + constraintRenames + ) + : undefined; const fact: ConstraintFact = { ...descriptor, + ...(finalConstraintName ? { constraintName: finalConstraintName } : {}), + ...(descriptor.constraintName && finalConstraintName !== descriptor.constraintName + ? { originalConstraintName: descriptor.constraintName } + : {}), filePath: foreignKey.filePath, line: foreignKey.startLine, + column: foreignKey.startColumn, }; const existing = grouped.get(key); if (existing) { @@ -113,7 +238,7 @@ function materializeForeignKeyEdges(grouped: Map): Edge synthesizedBy: POSTGRES_FOREIGN_KEY_SYNTHESIZER, postgresRelation: 'foreign-key', constraints: constraints.sort((a, b) => - a.filePath.localeCompare(b.filePath) || a.line - b.line + comparePostgresMigrationPosition(a, b) ), }, })); @@ -145,7 +270,52 @@ function postgresForeignKeyStateFingerprint( ])); hash.update('\n'); } - return { fingerprint: `v2:${hash.digest('hex')}`, factCount }; + // Rename facts and their exact alias candidates affect the projected FK + // endpoints even though neither is itself an FK fact. + for (const row of queries.iterateDecoratorReferenceState( + 'postgres', + POSTGRES_TABLE_RELATION_DECORATOR + )) { + let descriptor = null; + try { + descriptor = decodePostgresTableRelationDescriptor(JSON.parse(row.decorators)); + } catch { + // Malformed decorators are ignored by materialization too. + } + if (descriptor?.relation !== 'rename') continue; + hash.update(JSON.stringify(['rename', row])); + hash.update('\n'); + } + for (const row of queries.iterateDecoratorReferenceState( + 'postgres', + POSTGRES_DROP_CONSTRAINT_DECORATOR + )) { + hash.update(JSON.stringify(['drop-constraint', row])); + hash.update('\n'); + } + for (const row of queries.iterateDecoratorReferenceState( + 'postgres', + POSTGRES_RENAME_CONSTRAINT_DECORATOR + )) { + hash.update(JSON.stringify(['rename-constraint', row])); + hash.update('\n'); + } + for (const row of queries.iterateDecoratorReferenceState( + 'postgres', + POSTGRES_DROP_RELATION_DECORATOR + )) { + hash.update(JSON.stringify(['drop-relation', row])); + hash.update('\n'); + } + for (const node of queries.iterateNodesByLanguage('postgres')) { + if (!isPostgresTable(node)) continue; + hash.update(JSON.stringify([ + 'table', node.id, node.qualifiedName, node.filePath, node.startLine, + node.startColumn, node.decorators, + ])); + hash.update('\n'); + } + return { fingerprint: `v3:${hash.digest('hex')}`, factCount }; } function postgresForeignKeyOutputFingerprint( @@ -190,11 +360,17 @@ function persistCurrentFingerprint( export function postgresForeignKeyEdgesSync(queries: QueryBuilder): Edge[] { const grouped = new Map(); + const renames = new PostgresTableRenameTimeline(queries); + const lifecycle = new PostgresRelationLifecycle(queries, renames); + const drops = collectDropConstraintEvents(queries); + const constraintRenames = collectRenameConstraintEvents(queries); for (const foreignKey of queries.iterateNodesByLanguageWithDecorator( 'postgres', POSTGRES_FOREIGN_KEY_DECORATOR )) { - collectForeignKey(grouped, queries, foreignKey); + collectForeignKey( + grouped, queries, foreignKey, renames, lifecycle, drops, constraintRenames + ); } return materializeForeignKeyEdges(grouped); } @@ -204,13 +380,19 @@ export async function postgresForeignKeyEdges( onYield: MaybeYield ): Promise { const grouped = new Map(); + const renames = new PostgresTableRenameTimeline(queries); + const lifecycle = new PostgresRelationLifecycle(queries, renames); + const drops = collectDropConstraintEvents(queries); + const constraintRenames = collectRenameConstraintEvents(queries); let scanned = 0; for (const foreignKey of queries.iterateNodesByLanguageWithDecorator( 'postgres', POSTGRES_FOREIGN_KEY_DECORATOR )) { if ((++scanned & 127) === 0) await onYield(); - collectForeignKey(grouped, queries, foreignKey); + collectForeignKey( + grouped, queries, foreignKey, renames, lifecycle, drops, constraintRenames + ); } return materializeForeignKeyEdges(grouped); diff --git a/src/resolution/postgres-relation-lifecycle.ts b/src/resolution/postgres-relation-lifecycle.ts new file mode 100644 index 000000000..7239b800f --- /dev/null +++ b/src/resolution/postgres-relation-lifecycle.ts @@ -0,0 +1,119 @@ +import type { QueryBuilder } from '../db/queries'; +import { + POSTGRES_DROP_RELATION_DECORATOR, + decodePostgresDropRelationDescriptor, + type PostgresDroppedRelationKind, +} from '../postgres/relation-lifecycle'; +import { + PostgresTableRenameTimeline, + comparePostgresMigrationPosition, + isPostgresMigrationPositionLater, + type PostgresMigrationPosition, + type PostgresResolvedTableEndpoint, +} from './postgres-rename-timeline'; +import type { Node } from '../types'; + +export interface PostgresDropRelationEvent extends PostgresMigrationPosition { + nodeId: string; + relationName: string; + relationKind: PostgresDroppedRelationKind; +} + +/** Ordered DROP facts for deciding whether an older migration relation is live. */ +export class PostgresRelationLifecycle { + readonly drops: readonly PostgresDropRelationEvent[]; + + constructor( + queries: QueryBuilder, + private readonly renames: PostgresTableRenameTimeline + ) { + const drops: PostgresDropRelationEvent[] = []; + for (const fact of queries.iterateNodesByLanguageWithDecorator( + 'postgres', + POSTGRES_DROP_RELATION_DECORATOR + )) { + const descriptor = decodePostgresDropRelationDescriptor(fact.decorators); + if (!descriptor) continue; + drops.push({ + ...descriptor, + nodeId: fact.id, + filePath: fact.filePath, + line: fact.startLine, + column: fact.startColumn, + }); + } + drops.sort((left, right) => + comparePostgresMigrationPosition(left, right) || + (left.nodeId < right.nodeId ? -1 : left.nodeId > right.nodeId ? 1 : 0) + ); + this.drops = drops; + } + + /** True when a later DROP invalidates a relation fact at this position. */ + isDroppedAfter( + relationName: string, + position: PostgresMigrationPosition, + acceptedKinds: readonly PostgresDroppedRelationKind[] = ['table', 'foreign-table'] + ): boolean { + const canonicalRelation = this.renames.canonicalName(relationName, position); + return this.drops.some((drop) => + acceptedKinds.includes(drop.relationKind) && + isPostgresMigrationPositionLater(drop, position) && + this.renames.canonicalName(drop.relationName, drop) === canonicalRelation + ); + } + + /** + * Resolve a table endpoint at a migration position. When a name has been + * dropped and recreated, the generic resolver sees duplicate qualified names + * and leaves the fact unresolved; the DROP boundary makes the newest + * declaration after it unambiguous. + */ + canonicalTableEndpoint( + endpoints: readonly PostgresResolvedTableEndpoint[], + relationName: string, + position: PostgresMigrationPosition + ): Node | null { + const canonicalRelation = this.renames.canonicalName(relationName, position); + const resolved = this.renames.canonicalEndpoint(endpoints, relationName, position); + if (canonicalRelation !== relationName) return resolved; + + let latestDrop: PostgresDropRelationEvent | null = null; + for (const drop of this.drops) { + if (drop.relationKind !== 'table' && drop.relationKind !== 'foreign-table') continue; + if (!isPostgresMigrationPositionLater(position, drop)) continue; + if (this.renames.canonicalName(drop.relationName, drop) !== canonicalRelation) continue; + if (!latestDrop || comparePostgresMigrationPosition(drop, latestDrop) > 0) { + latestDrop = drop; + } + } + if (!latestDrop) return resolved; + return this.renames.latestExactTableBefore(canonicalRelation, position, latestDrop); + } + + /** + * Resolve the source side of a relation rename at that statement's position. + * A DROP followed by a same-named CREATE starts a new relation lifetime, so + * an otherwise ambiguous old-name reference belongs to the newest exact + * declaration after the DROP. + */ + renameSourceEndpoint( + endpoints: readonly PostgresResolvedTableEndpoint[], + relationName: string, + position: PostgresMigrationPosition + ): Node | null { + const resolved = this.renames.immediateRelationEndpoint(endpoints, relationName); + let latestDrop: PostgresDropRelationEvent | null = null; + for (const drop of this.drops) { + if (!isPostgresMigrationPositionLater(position, drop)) continue; + // Compare the name as it existed at the DROP. Projecting it through this + // rename would turn the source into the target and hide the boundary. + if (drop.relationName !== relationName) continue; + if (!latestDrop || comparePostgresMigrationPosition(drop, latestDrop) > 0) { + latestDrop = drop; + } + } + if (!latestDrop) return resolved; + return this.renames.latestExactRelationBefore(relationName, position, latestDrop); + } +} diff --git a/src/resolution/postgres-rename-timeline.ts b/src/resolution/postgres-rename-timeline.ts new file mode 100644 index 000000000..fbf6dd3fe --- /dev/null +++ b/src/resolution/postgres-rename-timeline.ts @@ -0,0 +1,269 @@ +import type { QueryBuilder } from '../db/queries'; +import type { Node } from '../types'; +import { isPostgresQualifiedName, parsePostgresQualifiedName } from '../postgres/identifiers'; +import { + POSTGRES_TABLE_RELATION_DECORATOR, + decodePostgresTableRelationDescriptor, +} from '../postgres/table-relation'; + +export interface PostgresMigrationPosition { + filePath: string; + line: number; + column: number; +} + +export interface PostgresResolvedTableEndpoint { + node: Node; + refName: string | undefined; +} + +export interface PostgresTableRenameEvent extends PostgresMigrationPosition { + nodeId: string; + sourceTable: string; + targetTable: string; +} + +/** + * CodeGraph has no database-migration executor, so file ordering is the only + * deterministic chronology available to the synthesizers. PostgreSQL facts + * are ordered by path, then their source position within that file. + */ +export function comparePostgresMigrationPosition( + left: PostgresMigrationPosition, + right: PostgresMigrationPosition +): number { + const pathOrder = left.filePath < right.filePath ? -1 : left.filePath > right.filePath ? 1 : 0; + return pathOrder || + left.line - right.line || + left.column - right.column; +} + +function postgresMigrationStream(filePath: string): string { + const normalized = filePath.replace(/\\/g, '/'); + const separator = normalized.lastIndexOf('/'); + return separator < 0 ? '' : normalized.slice(0, separator); +} + +export function isPostgresMigrationPositionLater( + candidate: PostgresMigrationPosition, + reference: PostgresMigrationPosition +): boolean { + // Separate directories are separate deployment streams unless a future + // project configuration explicitly says otherwise. Inferring chronology + // across e.g. migrations/, fixtures/, snapshots/, and tests/ would silently + // rewrite or suppress otherwise valid graph facts. + if (postgresMigrationStream(candidate.filePath) !== postgresMigrationStream(reference.filePath)) { + return false; + } + return comparePostgresMigrationPosition(candidate, reference) > 0; +} + +export function isPostgresTable(node: Node | null): node is Node { + return node?.language === 'postgres' && node.kind === 'struct' && ( + node.decorators?.includes('postgres:table') === true || + node.decorators?.includes('postgres:foreign-table') === true + ); +} + +export function isPostgresRelation(node: Node | null): node is Node { + return node?.language === 'postgres' && node.kind === 'struct' && ( + node.decorators?.includes('postgres:table') === true || + node.decorators?.includes('postgres:foreign-table') === true || + node.decorators?.includes('postgres:view') === true || + node.decorators?.includes('postgres:materialized-view') === true + ); +} + +function endpointFromFact( + endpoints: readonly PostgresResolvedTableEndpoint[], + name: string +): Node | null { + // refName preserves the role when both endpoint tables have the same simple + // name in different schemas. Fall back to node identity for older edges that + // predate refName metadata. + let matches = endpoints + .filter((endpoint) => endpoint.refName === name) + .map((endpoint) => endpoint.node); + if (matches.length === 0) { + const qualified = isPostgresQualifiedName(name); + const parsed = parsePostgresQualifiedName(name); + const simple = parsed?.[parsed.length - 1] ?? name; + matches = endpoints + .map((endpoint) => endpoint.node) + .filter((node) => qualified ? node.qualifiedName === name : node.name === simple); + } + const unique = new Map(matches.map((node) => [node.id, node])); + return unique.size === 1 ? unique.values().next().value ?? null : null; +} + +function nodePosition(node: Node): PostgresMigrationPosition { + return { + filePath: node.filePath, + line: node.startLine, + column: node.startColumn, + }; +} + +/** + * Pick the latest declaration before a migration fact, optionally bounded by a + * lifecycle event such as DROP. Candidates in other migration directories are + * deliberately ignored because their relative deployment order is unknown. + */ +export function latestPostgresMigrationNodeBefore( + candidates: readonly Node[], + position: PostgresMigrationPosition, + after?: PostgresMigrationPosition +): Node | null { + const preceding = candidates + .filter((candidate) => { + const candidatePosition = nodePosition(candidate); + return isPostgresMigrationPositionLater(position, candidatePosition) && + (!after || isPostgresMigrationPositionLater(candidatePosition, after)); + }) + .sort((left, right) => comparePostgresMigrationPosition( + nodePosition(right), + nodePosition(left) + )); + const latest = preceding[0]; + if (!latest) return null; + const latestPosition = nodePosition(latest); + return preceding.filter((candidate) => + comparePostgresMigrationPosition(nodePosition(candidate), latestPosition) === 0 + ).length === 1 + ? latest + : null; +} + +/** + * Ordered table rename facts plus safe exact-name lookup for their aliases. + * A lookup is usable only when exactly one PostgreSQL table owns the complete + * qualified name; the synthesizers never guess between migration versions. + */ +export class PostgresTableRenameTimeline { + readonly events: readonly PostgresTableRenameEvent[]; + private readonly exactTableCache = new Map(); + private readonly exactRelationCache = new Map(); + + constructor(private readonly queries: QueryBuilder) { + const events: PostgresTableRenameEvent[] = []; + for (const fact of queries.iterateNodesByLanguageWithDecorator( + 'postgres', + POSTGRES_TABLE_RELATION_DECORATOR + )) { + const descriptor = decodePostgresTableRelationDescriptor(fact.decorators); + if (descriptor?.relation !== 'rename') continue; + events.push({ + nodeId: fact.id, + sourceTable: descriptor.sourceTable, + targetTable: descriptor.targetTable, + filePath: fact.filePath, + line: fact.startLine, + column: fact.startColumn, + }); + } + events.sort((left, right) => + comparePostgresMigrationPosition(left, right) || + (left.nodeId < right.nodeId ? -1 : left.nodeId > right.nodeId ? 1 : 0) + ); + this.events = events; + } + + /** Follow only rename statements later than the fact being projected. */ + canonicalName(name: string, factPosition: PostgresMigrationPosition): string { + let current = name; + for (const event of this.events) { + if (!isPostgresMigrationPositionLater(event, factPosition)) continue; + if (event.sourceTable === current) current = event.targetTable; + } + return current; + } + + /** Resolve a rename's immediate old/new endpoints; do not collapse its edge. */ + immediateEndpoint( + endpoints: readonly PostgresResolvedTableEndpoint[], + name: string + ): Node | null { + return endpointFromFact(endpoints, name) ?? this.uniqueExactTable(name); + } + + /** Resolve a table/view rename without allowing relation-like nodes into FK matching. */ + immediateRelationEndpoint( + endpoints: readonly PostgresResolvedTableEndpoint[], + name: string + ): Node | null { + return endpointFromFact(endpoints, name) ?? this.uniqueExactRelation(name); + } + + /** + * Resolve a normal fact endpoint, then project it through subsequent rename + * statements. The exact global lookup is needed because a rename fact often + * resolves only its old reference; the new alias node is nevertheless in the + * graph. Ambiguous/missing aliases suppress the projection rather than + * retaining a stale edge to a name the migration has replaced. + */ + canonicalEndpoint( + endpoints: readonly PostgresResolvedTableEndpoint[], + name: string, + factPosition: PostgresMigrationPosition + ): Node | null { + const original = endpointFromFact(endpoints, name); + const canonicalName = this.canonicalName(name, factPosition); + if (canonicalName === name) return original; + return endpointFromFact(endpoints, canonicalName) ?? + this.uniqueExactTable(canonicalName); + } + + /** Resolve the newest exact table declaration inside a lifecycle window. */ + latestExactTableBefore( + qualifiedName: string, + position: PostgresMigrationPosition, + after?: PostgresMigrationPosition + ): Node | null { + return latestPostgresMigrationNodeBefore( + this.queries + .getNodesByQualifiedNameExact(qualifiedName) + .filter((node) => isPostgresTable(node)), + position, + after + ); + } + + /** Resolve the newest exact table/view declaration inside a lifecycle window. */ + latestExactRelationBefore( + qualifiedName: string, + position: PostgresMigrationPosition, + after?: PostgresMigrationPosition + ): Node | null { + return latestPostgresMigrationNodeBefore( + this.queries + .getNodesByQualifiedNameExact(qualifiedName) + .filter((node) => isPostgresRelation(node)), + position, + after + ); + } + + private uniqueExactTable(qualifiedName: string): Node | null { + if (this.exactTableCache.has(qualifiedName)) { + return this.exactTableCache.get(qualifiedName) ?? null; + } + const candidates = this.queries + .getNodesByQualifiedNameExact(qualifiedName) + .filter((node) => isPostgresTable(node)); + const table = candidates.length === 1 ? candidates[0]! : null; + this.exactTableCache.set(qualifiedName, table); + return table; + } + + private uniqueExactRelation(qualifiedName: string): Node | null { + if (this.exactRelationCache.has(qualifiedName)) { + return this.exactRelationCache.get(qualifiedName) ?? null; + } + const candidates = this.queries + .getNodesByQualifiedNameExact(qualifiedName) + .filter((node) => isPostgresRelation(node)); + const relation = candidates.length === 1 ? candidates[0]! : null; + this.exactRelationCache.set(qualifiedName, relation); + return relation; + } +} diff --git a/src/resolution/postgres-structure-synthesizer.ts b/src/resolution/postgres-structure-synthesizer.ts index 5c2434306..5a739b60d 100644 --- a/src/resolution/postgres-structure-synthesizer.ts +++ b/src/resolution/postgres-structure-synthesizer.ts @@ -4,23 +4,29 @@ import type { QueryBuilder } from '../db/queries'; import { parsePostgresQualifiedName, serializePostgresQualifiedName, - isPostgresQualifiedName, } from '../postgres/identifiers'; import { POSTGRES_TABLE_RELATION_DECORATOR, decodePostgresTableRelationDescriptor, type PostgresTableRelationDescriptor, } from '../postgres/table-relation'; +import { POSTGRES_DROP_RELATION_DECORATOR } from '../postgres/relation-lifecycle'; import type { MaybeYield } from './cooperative-yield'; +import { postgresEnumLifecycleEdges } from './postgres-enum-lifecycle'; +import { PostgresRelationLifecycle } from './postgres-relation-lifecycle'; +import { + PostgresTableRenameTimeline, + comparePostgresMigrationPosition, + isPostgresMigrationPositionLater, + isPostgresRelation, + isPostgresTable, + type PostgresMigrationPosition, + type PostgresResolvedTableEndpoint, +} from './postgres-rename-timeline'; export const POSTGRES_STRUCTURE_SYNTHESIZER = 'postgres-structure'; const POSTGRES_STRUCTURE_FINGERPRINT_METADATA = 'postgres_structure_state_fingerprint'; -interface ResolvedEndpoint { - node: Node; - refName: string | undefined; -} - interface RelationFact extends PostgresTableRelationDescriptor { filePath: string; line: number; @@ -41,30 +47,11 @@ const SCHEMA_OBJECT_DECORATORS = new Set([ 'postgres:index', ]); -function isTable(node: Node | null): node is Node { - return node?.language === 'postgres' && node.kind === 'struct' && ( - node.decorators?.includes('postgres:table') === true || - node.decorators?.includes('postgres:foreign-table') === true - ); -} - -function resolvedEndpoint(endpoints: ResolvedEndpoint[], name: string): Node | null { - let matches = endpoints - .filter((endpoint) => endpoint.refName === name) - .map((endpoint) => endpoint.node); - if (matches.length === 0) { - const qualified = isPostgresQualifiedName(name); - const parsed = parsePostgresQualifiedName(name); - const simple = parsed?.[parsed.length - 1] ?? name; - matches = endpoints - .map((endpoint) => endpoint.node) - .filter((node) => qualified ? node.qualifiedName === name : node.name === simple); - } - const unique = new Map(matches.map((node) => [node.id, node])); - return unique.size === 1 ? unique.values().next().value ?? null : null; -} - -function relationEdges(queries: QueryBuilder): Edge[] { +function relationEdges( + queries: QueryBuilder, + renames: PostgresTableRenameTimeline, + lifecycle: PostgresRelationLifecycle +): Edge[] { const edges: Edge[] = []; for (const factNode of queries.iterateNodesByLanguageWithDecorator( 'postgres', @@ -78,9 +65,30 @@ function relationEdges(queries: QueryBuilder): Edge[] { node: queries.getNodeById(edge.target), refName: typeof edge.metadata?.refName === 'string' ? edge.metadata.refName : undefined, })) - .filter((endpoint): endpoint is ResolvedEndpoint => isTable(endpoint.node)); - const source = resolvedEndpoint(endpoints, descriptor.sourceTable); - const target = resolvedEndpoint(endpoints, descriptor.targetTable); + .filter((endpoint): endpoint is PostgresResolvedTableEndpoint => + descriptor.relation === 'rename' + ? isPostgresRelation(endpoint.node) + : isPostgresTable(endpoint.node) + ); + const position: PostgresMigrationPosition = { + filePath: factNode.filePath, + line: factNode.startLine, + column: factNode.startColumn, + }; + if ( + descriptor.relation !== 'rename' && ( + lifecycle.isDroppedAfter(descriptor.sourceTable, position) || + lifecycle.isDroppedAfter(descriptor.targetTable, position) + ) + ) continue; + // A rename edge records the immediate transition. All other structural + // facts are projected through rename statements that occur after them. + const source = descriptor.relation === 'rename' + ? lifecycle.renameSourceEndpoint(endpoints, descriptor.sourceTable, position) + : lifecycle.canonicalTableEndpoint(endpoints, descriptor.sourceTable, position); + const target = descriptor.relation === 'rename' + ? renames.immediateRelationEndpoint(endpoints, descriptor.targetTable) + : lifecycle.canonicalTableEndpoint(endpoints, descriptor.targetTable, position); if (!source || !target) continue; const fact: RelationFact = { ...descriptor, @@ -110,6 +118,33 @@ function isSchemaObject(node: Node): boolean { node.decorators?.includes('postgres:temporary') !== true; } +function isEnum(node: Node): boolean { + return node.language === 'postgres' && node.kind === 'enum' && + node.decorators?.includes('postgres:enum') === true; +} + +function isEnumMember(node: Node): boolean { + return node.language === 'postgres' && node.kind === 'enum_member' && + node.decorators?.includes('postgres:enum-value') === true; +} + +function nativeContainmentTargets( + queries: QueryBuilder, + cache: Map>, + parent: Node +): Set { + let targets = cache.get(parent.id); + if (!targets) { + targets = new Set( + queries.getOutgoingEdges(parent.id, ['contains']) + .filter((edge) => edge.metadata?.synthesizedBy !== POSTGRES_STRUCTURE_SYNTHESIZER) + .map((edge) => edge.target) + ); + cache.set(parent.id, targets); + } + return targets; +} + function schemaContainmentEdges(queries: QueryBuilder): Edge[] { const schemas = new Map(); const nativeContainment = new Map>(); @@ -134,15 +169,7 @@ function schemaContainmentEdges(queries: QueryBuilder): Edge[] { ? candidates[0] : undefined; if (!schema) continue; - let nativeTargets = nativeContainment.get(schema.id); - if (!nativeTargets) { - nativeTargets = new Set( - queries.getOutgoingEdges(schema.id, ['contains']) - .filter((edge) => edge.metadata?.synthesizedBy !== POSTGRES_STRUCTURE_SYNTHESIZER) - .map((edge) => edge.target) - ); - nativeContainment.set(schema.id, nativeTargets); - } + const nativeTargets = nativeContainmentTargets(queries, nativeContainment, schema); if (nativeTargets.has(object.id)) continue; edges.push({ source: schema.id, @@ -160,8 +187,94 @@ function schemaContainmentEdges(queries: QueryBuilder): Edge[] { return edges; } +function enumContainmentEdges(queries: QueryBuilder): Edge[] { + const enums = new Map(); + const nativeContainment = new Map>(); + for (const node of queries.iterateNodesByLanguage('postgres')) { + if (!isEnum(node)) continue; + const existing = enums.get(node.qualifiedName); + if (existing) existing.push(node); + else enums.set(node.qualifiedName, [node]); + } + + const edges: Edge[] = []; + for (const member of queries.iterateNodesByLanguage('postgres')) { + if (!isEnumMember(member)) continue; + const parts = parsePostgresQualifiedName(member.qualifiedName); + if (!parts || parts.length < 2) continue; + const parentName = serializePostgresQualifiedName(parts.slice(0, -1)); + const candidates = enums.get(parentName) ?? []; + const memberPosition: PostgresMigrationPosition = { + filePath: member.filePath, + line: member.startLine, + column: member.startColumn, + }; + // ALTER TYPE values belong to the most recent preceding declaration in + // the same migration stream. This disambiguates a later DROP/re-CREATE of + // the same enum without attaching an older value to that future version. + const preceding = candidates + .filter((candidate) => isPostgresMigrationPositionLater(memberPosition, { + filePath: candidate.filePath, + line: candidate.startLine, + column: candidate.startColumn, + })) + .sort((left, right) => comparePostgresMigrationPosition({ + filePath: right.filePath, + line: right.startLine, + column: right.startColumn, + }, { + filePath: left.filePath, + line: left.startLine, + column: left.startColumn, + })); + const latest = preceding[0]; + const latestPosition = latest && { + filePath: latest.filePath, + line: latest.startLine, + column: latest.startColumn, + }; + const latestCandidates = latestPosition + ? preceding.filter((candidate) => comparePostgresMigrationPosition({ + filePath: candidate.filePath, + line: candidate.startLine, + column: candidate.startColumn, + }, latestPosition) === 0) + : []; + const sameFile = candidates.filter((candidate) => candidate.filePath === member.filePath); + const parent = latestCandidates.length === 1 + ? latestCandidates[0] + : preceding.length === 0 && sameFile.length === 1 + ? sameFile[0] + : preceding.length === 0 && sameFile.length === 0 && candidates.length === 1 + ? candidates[0] + : undefined; + if (!parent) continue; + if (nativeContainmentTargets(queries, nativeContainment, parent).has(member.id)) continue; + edges.push({ + source: parent.id, + target: member.id, + kind: 'contains', + line: member.startLine, + column: member.startColumn, + provenance: 'tree-sitter', + metadata: { + synthesizedBy: POSTGRES_STRUCTURE_SYNTHESIZER, + postgresRelation: 'enum-containment', + }, + }); + } + return edges; +} + function materializePostgresStructureEdges(queries: QueryBuilder): Edge[] { - return [...relationEdges(queries), ...schemaContainmentEdges(queries)]; + const renames = new PostgresTableRenameTimeline(queries); + const lifecycle = new PostgresRelationLifecycle(queries, renames); + return [ + ...relationEdges(queries, renames, lifecycle), + ...schemaContainmentEdges(queries), + ...enumContainmentEdges(queries), + ...postgresEnumLifecycleEdges(queries), + ]; } function structureInputFingerprint( @@ -181,14 +294,22 @@ function structureInputFingerprint( hash.update(JSON.stringify(['fact', row])); hash.update('\n'); } + for (const row of queries.iterateDecoratorReferenceState( + 'postgres', + POSTGRES_DROP_RELATION_DECORATOR + )) { + inputCount++; + hash.update(JSON.stringify(['drop-relation', row])); + hash.update('\n'); + } for (const node of queries.iterateNodesByLanguage('postgres')) { - if (node.kind !== 'namespace' && !isSchemaObject(node)) continue; + if (node.kind !== 'namespace' && !isSchemaObject(node) && !isEnumMember(node)) continue; inputCount++; hash.update(JSON.stringify([ 'node', node.id, node.kind, node.qualifiedName, node.filePath, node.decorators, ])); hash.update('\n'); - if (node.kind === 'namespace') { + if (node.kind === 'namespace' || isEnum(node)) { for (const edge of queries.getOutgoingEdges(node.id, ['contains'])) { if (edge.metadata?.synthesizedBy === POSTGRES_STRUCTURE_SYNTHESIZER) continue; hash.update(JSON.stringify([ @@ -198,7 +319,7 @@ function structureInputFingerprint( } } } - return { fingerprint: `v1:${hash.digest('hex')}`, inputCount }; + return { fingerprint: `v3:${hash.digest('hex')}`, inputCount }; } function structureOutputFingerprint( diff --git a/src/types.ts b/src/types.ts index d2d026087..872055494 100644 --- a/src/types.ts +++ b/src/types.ts @@ -1,3 +1,7 @@ +import type { PostgresObjectReferenceKind } from './postgres/reference-intent'; + +export type { PostgresObjectReferenceKind } from './postgres/reference-intent'; + /** * CodeGraph Type Definitions * @@ -320,12 +324,13 @@ export interface ExtractionError { } /** - * Kinds an unresolved reference can carry. `function_ref` is internal-only — - * a function name used as a VALUE (callback registration, #756). It never - * becomes an edge kind: resolution maps it to a `references` edge targeting - * function/method nodes only (see `matchFunctionRef`). + * Kinds an unresolved reference can carry. Internal-only intents never become + * edge kinds: resolution maps them to `references` after applying stricter + * target eligibility than an ordinary reference. `function_ref` targets only + * function/method nodes; PostgreSQL object intents retain exact object-class, + * quoted-name, and search_path semantics. */ -export type ReferenceKind = EdgeKind | 'function_ref'; +export type ReferenceKind = EdgeKind | 'function_ref' | PostgresObjectReferenceKind; /** * A reference that couldn't be resolved during extraction

    W-_=3vS?4P;5uD2`(TM+e{8p>%XGCKwxx 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 z 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%0Dk`Qd9jxo#>a&e!J=u7!JLZA6HKwgYHdZ(e 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 Q91WN3q&GlN1$~N~~hdJEmuT^yv_0GPUmL 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