mirror of
https://github.com/mauriceboe/TREK.git
synced 2026-11-20 02:56:10 +00:00
a884539a2b
Plugin statements on Postgres went over the extended query protocol through a marker parameter and a hook that replaced query() on every client of TREK's pool. That kept a plugin to one statement per round trip, but it changed TREK's own hot path for a concern only plugin data has. The plugin data store now checks a pg client out of the ORM's pool for each transaction, through MikroORM's getNativeClient, and runs the transaction on it directly. Every plugin write goes as a query with queryMode 'extended' and every read through a pg-cursor on that client, so Postgres parses exactly one statement either way. The settings the transaction makes are local, and before the client goes back to the pool the store drops temporary tables, cursors, listeners, session advisory locks and sequence state, or closes a client it cannot bring back to that state. The row cap, quota, time budget, untimed migrate, per-plugin queue, pool share and script commits are as before, and plugin args are still sent without NUL. The marker, the hook and its install in the Postgres driver are gone.
420 lines
20 KiB
TypeScript
420 lines
20 KiB
TypeScript
/**
|
||
* PGPLUG-001..012 — a plugin's own data (`db:own`) on Postgres, against the
|
||
* real app on the lane's database: each plugin gets a schema of its own and no
|
||
* SQLite file, its SQL keeps the SQLite store's semantics (migrate once per
|
||
* id, a script's statements committed one by one, an atomic tx, the row cap,
|
||
* the time budget, the quota), it cannot reach TREK's tables or another
|
||
* plugin's schema however it spells the name, every statement runs alone,
|
||
* the pool client a call used goes back without anything the call set, and
|
||
* erasing a plugin drops its schema and nothing else.
|
||
*/
|
||
import { buildApp } from '../../src/bootstrap';
|
||
import {
|
||
type ConnectPluginClient,
|
||
PluginDataSlots,
|
||
type PluginSqlClient,
|
||
poolClients,
|
||
PostgresPluginDataStore,
|
||
} from '../../src/db/engine/postgres/plugin-data-store';
|
||
import { withRequestContext } from '../../src/nest/database/request-context';
|
||
import { PLUGIN_DATA, type PluginDataBackend } from '../../src/nest/plugins/host/plugin-data.backend';
|
||
import { closePluginDataDb } from '../../src/nest/plugins/host/plugin-host-state';
|
||
import { PluginRpcHostFactory } from '../../src/nest/plugins/host/plugin-rpc-host.factory';
|
||
import { MikroORM } from '@mikro-orm/core';
|
||
import type { INestApplication } from '@nestjs/common';
|
||
|
||
import fs from 'node:fs';
|
||
import os from 'node:os';
|
||
import path from 'node:path';
|
||
import Cursor from 'pg-cursor';
|
||
import { afterAll, beforeAll, describe, expect, it } from 'vitest';
|
||
|
||
let app: INestApplication;
|
||
let orm: MikroORM;
|
||
let data: PluginDataBackend;
|
||
let dataDir: string;
|
||
|
||
beforeAll(async () => {
|
||
dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'trek-pg-plugin-data-'));
|
||
process.env.TREK_PLUGINS_DATA_DIR = dataDir;
|
||
app = await buildApp();
|
||
orm = app.get(MikroORM);
|
||
data = app.get<PluginDataBackend>(PLUGIN_DATA, { strict: false });
|
||
}, 60_000);
|
||
|
||
afterAll(async () => {
|
||
await app?.close();
|
||
delete process.env.TREK_PLUGINS_DATA_DIR;
|
||
fs.rmSync(dataDir, { recursive: true, force: true });
|
||
});
|
||
|
||
/** The plugin schemas the database holds now. */
|
||
async function pluginSchemas(): Promise<string[]> {
|
||
const rows = await withRequestContext(orm, () =>
|
||
orm.em
|
||
.getConnection()
|
||
.execute<Array<{ nspname: string }>>(
|
||
"select nspname from pg_namespace where starts_with(nspname, 'trek_plugin_') order by nspname",
|
||
[],
|
||
'all',
|
||
),
|
||
);
|
||
return rows.map((row) => row.nspname);
|
||
}
|
||
|
||
/** Clients of the app's pool, as the backend hands them to a store. */
|
||
function appClients(): ConnectPluginClient {
|
||
return poolClients(orm.em.getConnection());
|
||
}
|
||
|
||
/** A store on the app's pool with limits small enough to reach in a test. */
|
||
function cappedStore(id: string, limits: { maxRows?: number; timeBudgetMs?: number; quotaBytes?: number }) {
|
||
return new PostgresPluginDataStore(id, appClients(), new PluginDataSlots(1), limits);
|
||
}
|
||
|
||
/** `client` for every call of a store, kept checked out by the test: a release only records whether it would close it. */
|
||
function keep(client: PluginSqlClient, released: boolean[] = []): ConnectPluginClient {
|
||
return async () =>
|
||
({
|
||
query: (arg: never) => client.query(arg),
|
||
release: (destroy?: boolean) => released.push(destroy === true),
|
||
}) as unknown as PluginSqlClient;
|
||
}
|
||
|
||
/**
|
||
* Pool clients that hand Postgres `swap[text]` in place of a plugin statement
|
||
* whose text is `text`, as a store would if the guard let a second statement
|
||
* through: as an extended query or as a cursor, whichever the store sends.
|
||
*/
|
||
function smuggling(swap: Record<string, string>): ConnectPluginClient {
|
||
const connect = appClients();
|
||
return async () => {
|
||
const client = await connect();
|
||
const query = (arg: unknown): unknown => {
|
||
if (arg instanceof Cursor) {
|
||
const cursor = arg as unknown as { text: string };
|
||
cursor.text = swap[cursor.text] ?? cursor.text;
|
||
return client.query(arg);
|
||
}
|
||
const config = arg as { text?: unknown; values: unknown[] };
|
||
if (typeof config.text === 'string' && swap[config.text]) {
|
||
return client.query({ ...config, text: swap[config.text] });
|
||
}
|
||
return client.query(arg as never);
|
||
};
|
||
return { query, release: (destroy?: boolean) => client.release(destroy) } as unknown as PluginSqlClient;
|
||
};
|
||
}
|
||
|
||
describe('plugin data on Postgres', () => {
|
||
it('PGPLUG-001: a plugin gets a schema of its own, migrates once per id, reads and writes there, and no SQLite file', async () => {
|
||
const store = data.open('pg-alpha');
|
||
expect(store.engine).toBe('postgres');
|
||
expect(await store.migrate('001', 'CREATE TABLE notes (id bigserial PRIMARY KEY, body text NOT NULL)')).toEqual({
|
||
applied: true,
|
||
});
|
||
expect(await store.migrate('001', 'CREATE TABLE never (x int)')).toEqual({ applied: false });
|
||
expect(await store.exec('INSERT INTO notes (body) VALUES ($1), ($2)', ['a', 'b'])).toEqual({ changes: 2 });
|
||
expect(await store.query('SELECT body FROM notes WHERE body <> $1 ORDER BY id', ['x'])).toEqual([
|
||
{ body: 'a' },
|
||
{ body: 'b' },
|
||
]);
|
||
|
||
expect(await pluginSchemas()).toContain('trek_plugin_pg_alpha');
|
||
expect(fs.readdirSync(path.join(dataDir, 'pg-alpha'))).toEqual([]);
|
||
});
|
||
|
||
it('PGPLUG-002: a script commits statement by statement, a tx all or nothing', async () => {
|
||
const store = data.open('pg-script');
|
||
await store.migrate('001', 'CREATE TABLE kv (k text PRIMARY KEY, n int NOT NULL)');
|
||
|
||
await expect(store.exec("INSERT INTO kv VALUES ('one', 1); INSERT INTO kv VALUES ('one', 2)")).rejects.toThrow(
|
||
/duplicate key/,
|
||
);
|
||
expect(await store.query('SELECT k, n FROM kv')).toEqual([{ k: 'one', n: 1 }]);
|
||
|
||
await expect(
|
||
store.tx([
|
||
{ sql: 'UPDATE kv SET n = n + 1 WHERE k = $1', args: ['one'] },
|
||
{ sql: "INSERT INTO kv VALUES ('one', 9)" },
|
||
]),
|
||
).rejects.toThrow(/duplicate key/);
|
||
expect(await store.query('SELECT n FROM kv')).toEqual([{ n: 1 }]);
|
||
|
||
const batch = await store.tx([
|
||
{ sql: "INSERT INTO kv VALUES ('two', 2)" },
|
||
{ sql: 'SELECT k FROM kv ORDER BY k' },
|
||
{ sql: "UPDATE kv SET n = 3 WHERE k = 'two' RETURNING n" },
|
||
]);
|
||
expect(batch.results).toEqual([{ changes: 1 }, { rows: [{ k: 'one' }, { k: 'two' }] }, { rows: [{ n: 3 }] }]);
|
||
await expect(store.tx([{ sql: 'COMMIT' }])).rejects.toThrow(/transaction-control/);
|
||
await expect(store.query('SELECT n FROM kv WHERE k = ?', ['one'])).rejects.toThrow(/\$1, \$2/);
|
||
});
|
||
|
||
it("PGPLUG-003: a plugin cannot read TREK's tables, however it spells their name", async () => {
|
||
const store = data.open('pg-alpha');
|
||
// Unqualified, the name finds nothing: only the plugin's schema is on the search_path.
|
||
await expect(store.query('SELECT email FROM users')).rejects.toThrow(/does not exist/);
|
||
await Promise.all(
|
||
[
|
||
'SELECT email FROM public.users',
|
||
'SELECT email FROM "public"."users"',
|
||
'SELECT email FROM PUBLIC . users',
|
||
'SELECT email FROM public/* x */.users',
|
||
"SELECT query_to_xml('select email from public.users', true, true, '')",
|
||
"SELECT ts_stat('select to_tsvector(email) from public.users')",
|
||
'SELECT * FROM pg_catalog.pg_tables',
|
||
'SELECT * FROM pg_stats',
|
||
'SELECT * FROM information_schema.tables',
|
||
"SELECT set_config('search_path', 'public', true)",
|
||
"SELECT setval('public.users_id_seq', 1)",
|
||
"SELECT 'public.users'::regclass",
|
||
'SELECT database_to_xml(true, true, $$x$$)',
|
||
"SELECT E'\\'' || 'x'",
|
||
].map((sql) => expect(store.query(sql), sql).rejects.toThrow(/not allowed for plugin databases/)),
|
||
);
|
||
await Promise.all(
|
||
[
|
||
'CREATE TEMP TABLE t (x int)',
|
||
'SELECT 1 AS x INTO t2',
|
||
'CREATE FUNCTION f() RETURNS int LANGUAGE sql AS $$ SELECT 1 $$',
|
||
'ALTER TABLE notes SET SCHEMA public',
|
||
'ALTER TABLE notes OWNER TO postgres',
|
||
'CREATE SCHEMA mine',
|
||
'DROP SCHEMA trek_plugin_pg_alpha CASCADE',
|
||
'SET search_path TO public',
|
||
"COPY notes TO '/tmp/x'",
|
||
'CREATE TABLE copy AS SELECT * FROM public.users',
|
||
'CREATE VIEW v AS SELECT email FROM public.users',
|
||
'GRANT SELECT ON notes TO PUBLIC',
|
||
'DROP OWNED BY CURRENT_USER',
|
||
].map((sql) => expect(store.exec(sql), sql).rejects.toThrow(/not allowed/)),
|
||
);
|
||
// Nothing of TREK's was touched along the way.
|
||
const [{ n }] = await withRequestContext(orm, () =>
|
||
orm.em.getConnection().execute<Array<{ n: number }>>('select count(*) as n from users', [], 'all'),
|
||
);
|
||
expect(n).toBeGreaterThanOrEqual(0);
|
||
});
|
||
|
||
it("PGPLUG-004: two plugins never see each other's schema, even with tables of one name", async () => {
|
||
const alpha = data.open('pg-alpha');
|
||
const beta = data.open('pg-beta');
|
||
await beta.migrate('001', 'CREATE TABLE notes (id bigserial PRIMARY KEY, body text NOT NULL)');
|
||
await beta.exec('INSERT INTO notes (body) VALUES ($1)', ['beta secret']);
|
||
|
||
expect(await alpha.query('SELECT body FROM notes ORDER BY id')).toEqual([{ body: 'a' }, { body: 'b' }]);
|
||
expect(await beta.query('SELECT body FROM notes')).toEqual([{ body: 'beta secret' }]);
|
||
await Promise.all(
|
||
[
|
||
'SELECT body FROM trek_plugin_pg_beta.notes',
|
||
'SELECT body FROM "trek_plugin_pg_beta".notes',
|
||
'SELECT body FROM trek_plugin_not_yet_installed.notes',
|
||
].map((sql) => expect(alpha.query(sql), sql).rejects.toThrow(/another schema/)),
|
||
);
|
||
// Its own schema, qualified, is fine.
|
||
expect(await alpha.query('SELECT count(*) AS n FROM trek_plugin_pg_alpha.notes')).toEqual([{ n: 2 }]);
|
||
});
|
||
|
||
it('PGPLUG-005: the row cap and the time budget hold, the budget even inside one statement', async () => {
|
||
const store = cappedStore('pg-capped', { maxRows: 5, timeBudgetMs: 300 });
|
||
await expect(store.query('SELECT x FROM generate_series(1, 10) AS g(x)')).rejects.toThrow(
|
||
'query returned more than 5 rows',
|
||
);
|
||
expect(await store.query('SELECT x FROM generate_series(1, 5) AS g(x)')).toHaveLength(5);
|
||
await expect(
|
||
store.tx([{ sql: 'SELECT 1 FROM generate_series(1, 3)' }, { sql: 'SELECT 1 FROM generate_series(1, 3)' }]),
|
||
).rejects.toThrow('tx returned more than 5 rows in total');
|
||
await expect(store.query('SELECT count(*) FROM generate_series(1, 2000000000)')).rejects.toThrow(
|
||
'query exceeded its 300 ms time budget',
|
||
);
|
||
});
|
||
|
||
it('PGPLUG-006: a write that takes the schema past its quota is rolled back, a delete still runs', async () => {
|
||
const store = cappedStore('pg-quota', { quotaBytes: 64 * 1024 });
|
||
await store.migrate('001', 'CREATE TABLE blobs (body text)');
|
||
await store.exec("INSERT INTO blobs SELECT repeat('x', 100) FROM generate_series(1, 10)");
|
||
await expect(
|
||
store.exec('INSERT INTO blobs SELECT md5(x::text) FROM generate_series(1, 20000) AS g(x)'),
|
||
).rejects.toThrow(/past its 0\.0625 MB quota/);
|
||
expect(await store.query('SELECT count(*) AS n FROM blobs')).toEqual([{ n: 10 }]);
|
||
expect(await store.exec('DELETE FROM blobs WHERE length(body) > $1', [0])).toEqual({ changes: 10 });
|
||
});
|
||
|
||
it('PGPLUG-007: erasing a plugin drops its schema and its data directory, and only its own', async () => {
|
||
data.open('pg-gone');
|
||
await data.open('pg-gone').migrate('001', 'CREATE TABLE t (x int)');
|
||
expect(fs.existsSync(path.join(dataDir, 'pg-gone'))).toBe(true);
|
||
|
||
await data.erase('pg-gone');
|
||
|
||
const schemas = await pluginSchemas();
|
||
expect(schemas).not.toContain('trek_plugin_pg_gone');
|
||
expect(schemas).toEqual(expect.arrayContaining(['trek_plugin_pg_alpha', 'trek_plugin_pg_beta']));
|
||
expect(fs.existsSync(path.join(dataDir, 'pg-gone'))).toBe(false);
|
||
// An id no schema can be made from has nothing to drop.
|
||
await expect(data.erase('Not_An_Id')).resolves.toBeUndefined();
|
||
});
|
||
|
||
it('PGPLUG-008: through the RPC host, db.* reaches the plugin schema and db.engine says postgres', async () => {
|
||
const router = { callPlugin: async () => undefined, emitPluginEvent: async () => {} };
|
||
const host = app.get(PluginRpcHostFactory).create('pg-rpc', new Set(['db:own']), router);
|
||
const call = (method: string, params: Record<string, unknown>) =>
|
||
host.dispatch({ k: 'req', id: method, method, params });
|
||
|
||
expect(await call('db.engine', {})).toMatchObject({ ok: true, result: { engine: 'postgres' } });
|
||
expect(await call('db.migrate', { id: '001', sql: 'CREATE TABLE t (v text)' })).toMatchObject({ ok: true });
|
||
expect(await call('db.exec', { sql: 'INSERT INTO t VALUES ($1)', args: ['x'] })).toMatchObject({
|
||
ok: true,
|
||
result: { changes: 1 },
|
||
});
|
||
expect(await call('db.query', { sql: 'SELECT v FROM t' })).toMatchObject({ ok: true, result: [{ v: 'x' }] });
|
||
expect(await call('db.query', { sql: 'SELECT email FROM public.users' })).toMatchObject({
|
||
ok: false,
|
||
error: { code: 'HOST_ERROR' },
|
||
});
|
||
expect(await pluginSchemas()).toContain('trek_plugin_pg_rpc');
|
||
closePluginDataDb('pg-rpc');
|
||
});
|
||
|
||
it("PGPLUG-009: the review's bypasses are refused before they run: SQL hidden behind a CR, and SELECT ... INTO TEMP", async () => {
|
||
const store = data.open('pg-bypass');
|
||
await store.migrate('001', 'CREATE TABLE notes (id bigserial PRIMARY KEY, body text NOT NULL)');
|
||
const reads = [
|
||
'select 1 --\rfrom public.users',
|
||
'select 1 --x\rfrom public.users',
|
||
'select 1 --\r, email, password_hash from public.users',
|
||
"(select 1 as id, 'admin' as role into temp users)",
|
||
"(select 99 as id, 'forged'::text as name into temp users)",
|
||
'((select 1 into t))',
|
||
'(select 1) into t',
|
||
'select * from (select 1 into t) s',
|
||
'select 1 from public.users',
|
||
];
|
||
await Promise.all(reads.map((sql) => expect(store.query(sql), sql).rejects.toThrow(/not allowed for plugin/)));
|
||
const scripts = [
|
||
"select 1 --\r; reset search_path; update users set role = 'admin' where id = 1",
|
||
"insert into notes (body) values ('x') --x\r; update public.users set role = 1",
|
||
"select 1 --x\r; create function f() returns int language sql as 'select 1'",
|
||
"select 1 --\r; copy notes to program 'id'",
|
||
'(select 1 into temp t)',
|
||
'select 1 into temporary t',
|
||
];
|
||
await Promise.all(scripts.map((sql) => expect(store.exec(sql), sql).rejects.toThrow(/not allowed for plugin/)));
|
||
|
||
// Nothing hidden ran: no temporary table anywhere in the database, no function. The insert in front of the
|
||
// CR is a statement of its own, which a script commits before the next one is refused, as on SQLite.
|
||
const [{ temps, functions }] = await withRequestContext(orm, () =>
|
||
orm.em
|
||
.getConnection()
|
||
.execute<Array<{ temps: number; functions: number }>>(
|
||
"select (select count(*) from pg_class where relpersistence = 't') as temps, " +
|
||
"(select count(*) from pg_proc where proname = 'f') as functions",
|
||
[],
|
||
'all',
|
||
),
|
||
);
|
||
expect({ temps, functions }).toEqual({ temps: 0, functions: 0 });
|
||
expect(await store.query('SELECT body FROM notes')).toEqual([{ body: 'x' }]);
|
||
});
|
||
|
||
it('PGPLUG-010: every plugin statement runs alone: a second one smuggled into its text is refused by Postgres, not run', async () => {
|
||
const store = data.open('pg-proto');
|
||
await store.migrate('001', 'CREATE TABLE t (x int)');
|
||
const two = 'insert into trek_plugin_pg_proto.t values (1); insert into trek_plugin_pg_proto.t values (2)';
|
||
|
||
// What the store would hand Postgres if the guard let a second statement through, as a write and as a read.
|
||
const fooled = new PostgresPluginDataStore(
|
||
'pg-proto',
|
||
smuggling({ 'INSERT INTO t VALUES (7)': two, 'SELECT x FROM t': `select x from t; ${two}` }),
|
||
new PluginDataSlots(1),
|
||
);
|
||
await expect(fooled.exec('INSERT INTO t VALUES (7)')).rejects.toThrow(
|
||
/cannot insert multiple commands into a prepared statement/,
|
||
);
|
||
await expect(fooled.exec('INSERT INTO t VALUES (7)', [])).rejects.toThrow(/cannot insert multiple commands/);
|
||
await expect(fooled.tx([{ sql: 'INSERT INTO t VALUES (7)' }])).rejects.toThrow(/cannot insert multiple commands/);
|
||
await expect(fooled.query('SELECT x FROM t')).rejects.toThrow(/cannot insert multiple commands/);
|
||
expect(await store.query('SELECT count(*) AS n FROM t')).toEqual([{ n: 0 }]);
|
||
|
||
// The same text over the simple protocol runs both, which is what sending each statement extended prevents.
|
||
const client = await appClients()();
|
||
try {
|
||
await client.query(two);
|
||
} finally {
|
||
client.release();
|
||
}
|
||
expect(await store.query('SELECT count(*) AS n FROM t')).toEqual([{ n: 2 }]);
|
||
|
||
// A single statement runs and reports its rows, with or without args.
|
||
expect(await store.exec('DELETE FROM t WHERE x = $1', [1])).toEqual({ changes: 1 });
|
||
expect(await store.exec('DELETE FROM t')).toEqual({ changes: 0 });
|
||
expect(await store.exec('INSERT INTO t VALUES (5)', [])).toEqual({ changes: 0 });
|
||
expect(await store.tx([{ sql: 'INSERT INTO t VALUES (6)' }, { sql: 'DELETE FROM t' }])).toEqual({
|
||
results: [{ changes: 1 }, { changes: 2 }],
|
||
});
|
||
});
|
||
|
||
it("PGPLUG-011: pg_temp is searched last, so a temporary table never stands in for TREK's tables or a plugin's", async () => {
|
||
const [{ path, schema }] = await withRequestContext(orm, () =>
|
||
orm.em
|
||
.getConnection()
|
||
.execute<Array<{ path: string; schema: string }>>(
|
||
"select current_setting('search_path') as path, current_schema() as schema",
|
||
[],
|
||
'all',
|
||
),
|
||
);
|
||
expect(path).toMatch(/, pg_temp$/);
|
||
expect(schema).toBe('public');
|
||
|
||
const store = data.open('pg-shadow');
|
||
await store.migrate('001', 'CREATE TABLE notes (body text)');
|
||
await store.exec('INSERT INTO notes VALUES ($1)', ['real']);
|
||
// A pool client holding temporary tables named like TREK's and the plugin's, as one left behind would.
|
||
const client = await appClients()();
|
||
try {
|
||
await client.query("create temp table users as select 'forged'::text as email");
|
||
await client.query("create temp table notes as select 'forged'::text as body");
|
||
const released: boolean[] = [];
|
||
const onClient = new PostgresPluginDataStore('pg-shadow', keep(client, released), new PluginDataSlots(1));
|
||
expect(await onClient.query('SELECT body FROM notes')).toEqual([{ body: 'real' }]);
|
||
// The call dropped them with the rest of the session's state before it gave the client back.
|
||
const temps = await client.query(
|
||
"select count(*)::int as n from pg_class where relpersistence = 't' and relnamespace = pg_my_temp_schema()",
|
||
);
|
||
expect(temps.rows).toEqual([{ n: 0 }]);
|
||
expect(released).toEqual([false]);
|
||
} finally {
|
||
await client.query('drop table if exists pg_temp.users, pg_temp.notes');
|
||
client.release();
|
||
}
|
||
});
|
||
|
||
it('PGPLUG-012: a call leaves nothing it set on the pool client it used, a cancelled one neither', async () => {
|
||
const store = data.open('pg-session');
|
||
await store.migrate('001', 'CREATE TABLE notes (body text)');
|
||
const settings =
|
||
"select current_setting('search_path') as path, current_setting('statement_timeout') as timeout, " +
|
||
"current_setting('standard_conforming_strings') as strings, now() = statement_timestamp() as outside";
|
||
const client = await appClients()();
|
||
try {
|
||
const before = await client.query(settings);
|
||
const released: boolean[] = [];
|
||
const onClient = new PostgresPluginDataStore('pg-session', keep(client, released), new PluginDataSlots(1), {
|
||
timeBudgetMs: 300,
|
||
});
|
||
await onClient.tx([{ sql: "INSERT INTO notes VALUES ('a')" }, { sql: 'SELECT body FROM notes' }]);
|
||
await expect(onClient.query('SELECT count(*) FROM generate_series(1, 2000000000)')).rejects.toThrow(
|
||
'query exceeded its 300 ms time budget',
|
||
);
|
||
await onClient.migrate('002', 'CREATE INDEX notes_body ON notes (body)');
|
||
// Same search_path and settings as before, and no transaction left open (now() moves with each statement).
|
||
expect((await client.query(settings)).rows).toEqual(before.rows);
|
||
expect(released).toEqual([false, false, false]);
|
||
} finally {
|
||
client.release();
|
||
}
|
||
});
|
||
});
|