pgkiln 0.35.0 → 0.37.0

package/src/cli/main.ts

@@ -133,6 +133,51 @@ const COMMANDS: Record<string, Command> = {
     },
   },
 
+  ddl: {
+    usage: 'pgkiln ddl <schema> [--no-comments] [--no-grants] [--out <file>]',
+    summary: 'write the DDL of a schema\'s objects (SQL Workshop → Generate DDL)',
+    details:
+      'Types, sequences, tables, functions, views, constraints, indexes, triggers, row level security,\n' +
+      'comments and grants, in an order that runs, with the schema in search_path at the top (so the\n' +
+      'script also creates the objects in another schema). Objects of extensions are left out.',
+    options: { 'no-comments': { type: 'boolean' }, 'no-grants': { type: 'boolean' }, out: { type: 'string', short: 'o' } },
+    optionHelp: [['--no-comments', 'leave out comments'], ['--no-grants', 'leave out grants'], ['-o, --out <file>', 'write to a file instead of standard output']],
+    positionals: [1, 1],
+    async run(v, [schema]) {
+      const { ddlScript, OBJECT_TYPES, pick, readSchema } = await import('../ddl.ts');
+      const objects = await withDb((db) => readSchema(db, schema));
+      const script = ddlScript(schema, pick(objects, new Set(OBJECT_TYPES), { comments: !v['no-comments'], grants: !v['no-grants'] }));
+      if (v.out) {
+        writeFileSync(v.out as string, script);
+        err(`Wrote the DDL of ${schema} to ${v.out}.\n`);
+      } else out(script);
+      return EXIT.ok;
+    },
+  },
+
+  compare: {
+    usage: 'pgkiln compare <source> <target> [--script]',
+    summary: 'compare two schemas (SQL Workshop → Schema Comparison); exit code 1 when they differ',
+    details:
+      'Lists what only the source has (+), what only the target has (-) and what differs (~), by their DDL;\n' +
+      'the order of a table\'s columns is not compared. --script writes the script that makes the target\n' +
+      'like the source instead (drops of what only the target has are commented out). Nothing is run.',
+    options: { script: { type: 'boolean' } },
+    optionHelp: [['--script', 'write the change script']],
+    positionals: [2, 2],
+    async run(v, [source, target]) {
+      const { changeScript, compare, readSchema } = await import('../ddl.ts');
+      const [a, b] = await withDb(async (db) => [await readSchema(db, source), await readSchema(db, target)]);
+      const { differences, same } = compare(a, b);
+      if (v.script) out(changeScript(source, target, a, b));
+      else {
+        for (const d of differences) out(`${d.state === 'source' ? '+' : d.state === 'target' ? '-' : '~'} ${d.kind} ${d.name}\n`);
+        err(differences.length ? `${differences.length} difference(s), ${same} object(s) the same.\n` : `The schemas are the same (${same} objects).\n`);
+      }
+      return differences.length ? EXIT.differences : EXIT.ok;
+    },
+  },
+
   export: {
     usage: 'pgkiln export <alias> [--format json|dir|text] [--out <path>]',
     summary: 'export an application as one JSON file or as a directory with a file per component',

package/src/cli/mcp.ts

@@ -473,6 +473,48 @@ export const TOOLS: Tool[] = [
       });
     },
   },
+  {
+    name: 'generate_ddl',
+    title: 'Generate the DDL of a schema',
+    description:
+      'The DDL of a schema\'s objects from the catalog (types, sequences, tables, functions, views, constraints, indexes, triggers, ' +
+      'row level security, comments and grants), in an order that runs, with the schema in search_path at the top. ' +
+      'Use it to start a migration script or to see how objects are defined; nothing is run.',
+    inputSchema: { type: 'object', properties: { schema: { type: 'string', description: 'the schema, e.g. sales' } }, required: ['schema'] },
+    annotations: { readOnlyHint: true },
+    async run(a) {
+      const schema = str(a, 'schema');
+      if (!schema) throw new ToolError('schema is required');
+      const { ddlScript, readSchema } = await import('../ddl.ts');
+      return withDb(async (db) => cap(ddlScript(schema, await readSchema(db, schema))));
+    },
+  },
+  {
+    name: 'compare_schemas',
+    title: 'Compare two schemas',
+    description:
+      'Compares the objects of two schemas of the database by their DDL: what only the source has (+), only the target has (-), ' +
+      'and what differs (~), followed by a script that makes the target like the source (drops commented out). Nothing is run.',
+    inputSchema: {
+      type: 'object',
+      properties: { source: { type: 'string', description: 'the schema to compare with, e.g. sales' }, target: { type: 'string', description: 'the schema to make like the source, e.g. sales_dev' } },
+      required: ['source', 'target'],
+    },
+    annotations: { readOnlyHint: true },
+    async run(a) {
+      const source = str(a, 'source');
+      const target = str(a, 'target');
+      if (!source || !target) throw new ToolError('source and target are required');
+      const { changeScript, compare, readSchema } = await import('../ddl.ts');
+      return withDb(async (db) => {
+        const [x, y] = [await readSchema(db, source), await readSchema(db, target)];
+        const { differences, same } = compare(x, y);
+        if (!differences.length) return `The schemas are the same (${same} objects).\n`;
+        const list = differences.map((d) => `${d.state === 'source' ? '+' : d.state === 'target' ? '-' : '~'} ${d.kind} ${d.name}`).join('\n');
+        return cap(`${differences.length} difference(s), ${same} object(s) the same:\n${list}\n\n${changeScript(source, target, x, y)}`);
+      });
+    },
+  },
   {
     name: 'run_query',
     title: 'Run a read-only query',

package/src/cli/replace.ts

@@ -26,9 +26,13 @@ export const REPLACED = [
   'search_config', 'email_template',
   // (086) application settings (installed values kept, see below), dynamic translations
   'app_setting', 'dynamic_translation',
+  // (089) page groups
+  'page_group',
 ];
 /** Tables of an application that belong to the installation: kept. */
 export const KEPT = ['app_access', 'api_client', 'session', 'sso_pending', 'saved_report', 'persistent_login', 'task', 'workflow', 'process_job',
+  // (087) password reset links of this installation's accounts
+  'password_reset',
   // (042) builder state of this installation: locks and developer comments (by page number)
   'builder_lock', 'dev_comment',
   // (051) debug messages recorded by this installation

package/src/db.ts

@@ -13,7 +13,7 @@ const inTx = new AsyncLocalStorage<ReadonlySet<string>>();
 /** Waiting for a free connection fails after this, instead of hanging the request forever. */
 const ACQUIRE_TIMEOUT_MS = Number(process.env.DB_ACQUIRE_TIMEOUT_MS ?? 30_000);
 
-function makePool(connectionString: string | undefined, name: string) {
+export function makePool(connectionString: string | undefined, name: string, max = Number(process.env.DB_POOL_SIZE ?? 10)) {
   const opts = {
     connectionString,
     application_name: name,
@@ -21,7 +21,7 @@ function makePool(connectionString: string | undefined, name: string) {
     // a transaction left open (a bug, a hung client) is ended by the database and frees its connection
     idle_in_transaction_session_timeout: Number(process.env.DB_IDLE_IN_TRANSACTION_MS ?? 300_000),
   };
-  const pool = new pg.Pool({ ...opts, max: Number(process.env.DB_POOL_SIZE ?? 10) });
+  const pool = new pg.Pool({ ...opts, max });
   // A query issued while this async chain already holds a connection of this pool
   // (in tx()) must not wait for a second one from the same pool: with every
   // connection held by requests doing that, none would ever be released. Those
@@ -72,11 +72,36 @@ if (!process.env.RUNTIME_DATABASE_URL)
 
 /** Owner connection: builder, SQL Workshop, migrations. */
 export const owner = makePool(ownerUrl, 'pgkiln-builder');
-/** Least-privilege connection (pgkiln_runtime) that runs applications. */
-export const runtime = makePool(process.env.RUNTIME_DATABASE_URL ?? ownerUrl, 'pgkiln-runtime');
+export type Db = ReturnType<typeof makePool>;
+
+export const runtimeUrl = process.env.RUNTIME_DATABASE_URL ?? ownerUrl;
+/** The shared least-privilege connection (pgkiln_runtime): applications outside isolated workspaces. */
+export const sharedRuntime = makePool(runtimeUrl, 'pgkiln-runtime');
+
+/**
+ * The runtime connection of the current request or job: an isolated workspace's
+ * own login (src/workspace-db.ts sets it with runtimeScope.run) or the shared one.
+ */
+export const runtimeScope = new AsyncLocalStorage<Db>();
+const currentRuntime = () => runtimeScope.getStore() ?? sharedRuntime;
+
+/** Least-privilege connection that runs applications: the current scope's (see runtimeScope). */
+export const runtime: Db = {
+  get pool() {
+    return currentRuntime().pool;
+  },
+  query: (sql, params) => currentRuntime().query(sql, params),
+  one: (sql, params) => currentRuntime().one(sql, params),
+  tx: (fn) => currentRuntime().tx(fn),
+  end: () => sharedRuntime.end(),
+};
+
+const closers: (() => Promise<void>)[] = [];
+/** Pools made elsewhere (the workspaces' own) close with the others. */
+export const onClosePools = (fn: () => Promise<void>) => closers.push(fn);
 
 export async function closePools() {
-  await Promise.all([owner.end(), runtime.end()]);
+  await Promise.all([owner.end(), sharedRuntime.end(), ...closers.map((f) => f())]);
 }
 
 export interface AppContext {
@@ -123,8 +148,13 @@ export async function appTx<T>(ctx: AppContext, fn: (c: Client) => Promise<T>):
 
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 
+let appRuntime: (appId: number) => Promise<Db> = async () => currentRuntime();
+/** How appTx finds an application's runtime connection (src/workspace-db.ts: an isolated workspace's own). */
+export const setAppRuntime = (fn: (appId: number) => Promise<Db>) => (appRuntime = fn);
+
 async function appTxInner<T>(ctx: AppContext, fn: (c: Client) => Promise<T>): Promise<T> {
-  return runtime.tx(async (c) => {
+  const db = await appRuntime(ctx.appId);
+  return db.tx(async (c) => {
     await c.query(
       `select set_config('pgkiln.app_user', $1, true),
               set_config('pgkiln.session_id', $2, true),