@ultimat3/db 24.0.0 → 25.1.0

package/src/sql-scan.ts

@@ -3,10 +3,27 @@
 // disagreed with a guard about where a literal ends is a `;` sent as data or a `delete` read as
 // prose, and the two answers must be the same answer.
 
-const IDENTIFIER_START = /[A-Za-z_]/;
-export const IDENTIFIER_PART = /[A-Za-z0-9_]/;
-/** `$` is legal in an identifier after the first character — `a$b` is one name, not three. */
-const IDENTIFIER_TAIL = /[A-Za-z0-9_$]/;
+/**
+ * Postgres's `ident_start`/`dolq_start`: any non-ASCII character too (`\200-\377` per UTF-8 byte),
+ * so `$é$` opens a body and `é$x$` is one name — read against a server, `sql-scan.test.ts`.
+ */
+const IDENTIFIER_START = /[A-Za-z_\u0080-\uffff]/;
+/** A tag's `dolq_cont`: an identifier character without the `$`, non-ASCII included. */
+const TAG_PART = /[A-Za-z0-9_\u0080-\uffff]/;
+/**
+ * `ident_cont`: the one class every word scan in this package reads a name with. `$` is legal
+ * after the first character (`a$b` is one name, not three) and so is any non-ASCII one — an
+ * ASCII-only scan found `col` inside `écol` and never found `prénom` at all.
+ */
+export const IDENTIFIER_CHAR = /[A-Za-z0-9_$\u0080-\uffff]/;
+
+/**
+ * An unquoted name as a UTF8 server stores it: ASCII folded to lower case and nothing else —
+ * `Évent` stays `Évent` (read against a server, `dependent-view.test.ts`). `toLowerCase()` folded
+ * the `É` too and named a column the catalog does not hold.
+ */
+export const foldIdentifier = (name: string): string =>
+  name.replace(/[A-Z]+/g, (run) => run.toLowerCase());
 
 export type NoiseKind = 'line-comment' | 'block-comment' | 'string' | 'identifier' | 'dollar-body';
 
@@ -23,11 +40,13 @@ function skipLineComment(script: string, index: number): number {
 }
 
 /**
- * Past a block comment. Postgres **nests** them, so the depth is counted rather than matched to
- * the first terminator — a commented-out block that itself contains a comment closes once, and
- * every `;` after that point would otherwise be read as data.
+ * Past a block comment opening at `index`, or `null` when it never closes. Postgres **nests**
+ * them, so the depth is counted rather than matched to the first terminator — a commented-out
+ * block that itself contains a comment closes once, and every `;` after that point would otherwise
+ * be read as data. Exported for `@ultimat3/mcp`'s read-only check, which REFUSES an unclosed
+ * comment where this lexer runs it to the end: one rule for where a comment ends, two readers.
  */
-function skipBlockComment(script: string, index: number): number {
+export function endOfBlockComment(script: string, index: number): number | null {
   let depth = 0;
   let at = index;
   while (at < script.length) {
@@ -46,9 +65,13 @@ function skipBlockComment(script: string, index: number): number {
     }
     at += 1;
   }
-  return script.length;
+  return null;
 }
 
+/** An unclosed comment runs to the end: Postgres reports that syntax error, not this lexer. */
+const skipBlockComment = (script: string, index: number): number =>
+  endOfBlockComment(script, index) ?? script.length;
+
 /**
  * Past a run closing on `quote`, where a doubled quote is an escaped one — `'it''s'` and
  * `"a""b"` are each one token. `escapes` is the `E''` dialect, the only one where a backslash
@@ -84,7 +107,7 @@ function skipQuoted(script: string, index: number, quote: string, escapes: boole
  */
 function insideIdentifier(script: string, index: number): boolean {
   let at = index - 1;
-  while (at >= 0 && IDENTIFIER_TAIL.test(script[at] ?? '')) at -= 1;
+  while (at >= 0 && IDENTIFIER_CHAR.test(script[at] ?? '')) at -= 1;
   const first = script[at + 1];
   return at + 1 < index && first !== undefined && IDENTIFIER_START.test(first);
 }
@@ -104,7 +127,7 @@ export function dollarTagAt(script: string, index: number): string | null {
   let at = index + 1;
   while (at < script.length) {
     const char = script[at] ?? '';
-    const valid = at === index + 1 ? IDENTIFIER_START.test(char) : IDENTIFIER_PART.test(char);
+    const valid = at === index + 1 ? IDENTIFIER_START.test(char) : TAG_PART.test(char);
     if (!valid) break;
     at += 1;
   }
@@ -125,7 +148,9 @@ function escapesAt(script: string, index: number): boolean {
   const prefix = script[index - 1];
   if (prefix !== 'E' && prefix !== 'e') return false;
   const before = script[index - 2];
-  return before === undefined || !IDENTIFIER_PART.test(before);
+  // `IDENTIFIER_CHAR`, never an ASCII-only class: `éE` and `a$E` are names to Postgres,
+  // and reading their `E` as a prefix let a `\'` swallow the `;` before a `drop table`.
+  return before === undefined || !IDENTIFIER_CHAR.test(before);
 }
 
 /**

package/src/drift-fixtures.ts

@@ -1,23 +0,0 @@
-// TEST-ONLY. The two builders every drift suite compares with — a `TableDescription` of text
-// columns and the `SchemaDescription` around it. One copy, because three suites arguing about
-// schemas built differently would each be judging a different fixture. Never exported from
-// `index.ts`.
-
-import type { SchemaDescription, TableDescription } from './introspect';
-
-export const table = (name: string, columns: readonly string[]): TableDescription => ({
-  schema: 'public',
-  name,
-  columns: columns.map((column, index) => ({
-    name: column,
-    dataType: 'text',
-    nullable: true,
-    default: null,
-    position: index + 1,
-  })),
-  primaryKey: ['id'],
-  indexes: [],
-  foreignKeys: [],
-});
-
-export const schema = (...tables: readonly TableDescription[]): SchemaDescription => ({ tables });

package/src/fake-pglite.ts

@@ -1,32 +0,0 @@
-// Single responsibility: the PGlite driver fake the adapter tests record statements against.
-// Shared rather than copied for the same reason `fake-reservable.ts` is: the assertion in every
-// one of these tests is the recorded ORDER, and two copies of the recorder drift into two orders.
-
-import type { PgliteDriver, PgliteResult } from './pglite';
-
-/** One statement as the driver received it — the text after binding, and the bound values. */
-export interface Recorded {
-  readonly text: string;
-  readonly values: readonly unknown[];
-}
-
-export type RecordingPgliteDriver = PgliteDriver & {
-  readonly calls: Recorded[];
-  closed: number;
-};
-
-/** A driver that answers every statement with `result` and remembers the order it saw them in. */
-export function fakeDriver(result: PgliteResult): RecordingPgliteDriver {
-  const calls: Recorded[] = [];
-  return {
-    calls,
-    closed: 0,
-    async query(text, values) {
-      calls.push({ text, values: values ?? [] });
-      return result;
-    },
-    async close() {
-      this.closed += 1;
-    },
-  };
-}

package/src/fake-reservable.ts

@@ -1,50 +0,0 @@
-// Single responsibility: a `ReservableClient` whose pin is countable, wrapped over any `DbClient`.
-// The leak it exists to catch is invisible to the recording client — the statements are identical
-// whether or not the reservation ever came back, and only the counter says which happened. Shared
-// rather than copied: a second copy of a fixture asserts less than the first, silently.
-
-import type { DbClient, ReservableClient } from './client';
-
-/** Pins taken and pins given back. A leak is `reserves > releases`; the fix makes them equal. */
-export interface PinCounts {
-  reserves: number;
-  releases: number;
-}
-
-export interface ReservableFake {
-  readonly client: ReservableClient;
-  readonly pins: PinCounts;
-}
-
-/**
- * Wrap `inner` in a pool that counts its reservations. `release()` is idempotent and
- * `[Symbol.dispose]` is the same call, exactly as both real drivers are — so a double release
- * counts once and only a genuine leak leaves the counters uneven.
- */
-export function reservableOver(inner: DbClient): ReservableFake {
-  const pins: PinCounts = { reserves: 0, releases: 0 };
-  return {
-    pins,
-    client: {
-      query: (fragment) => inner.query(fragment),
-      one: (fragment) => inner.one(fragment),
-      execute: (fragment) => inner.execute(fragment),
-      reserve: async () => {
-        pins.reserves += 1;
-        let held = true;
-        const release = (): void => {
-          if (!held) return;
-          held = false;
-          pins.releases += 1;
-        };
-        return {
-          query: (fragment) => inner.query(fragment),
-          one: (fragment) => inner.one(fragment),
-          execute: (fragment) => inner.execute(fragment),
-          release,
-          [Symbol.dispose]: release,
-        };
-      },
-    },
-  };
-}