@pikku/kysely 0.13.6 → 0.13.10

package/src/schema/schema.test.ts

@@ -398,10 +398,9 @@ describe('ensurePikkuSchema — a connection bound to a schema', () => {
     // raise a syntax error of its own on this DDL — a column type resolved from
     // `requires` goes in verbatim. Answering for it in sqlite's name would be
     // the misleading-error bug, reintroduced.
-    const pgError = Object.assign(
-      new Error('syntax error at or near "not"'),
-      { code: '42601' }
-    )
+    const pgError = Object.assign(new Error('syntax error at or near "not"'), {
+      code: '42601',
+    })
     const db = new Kysely<any>({
       dialect: {
         ...dialect('postgres'),
@@ -454,3 +453,82 @@ describe('ensurePikkuSchema — a connection bound to a schema', () => {
     )
   })
 })
+
+describe('compiling into a schema', () => {
+  const compilePg = (schemaName?: string) =>
+    compilePikkuSchemas(
+      new Kysely<any>({ dialect: dialect('postgres') }),
+      pikkuSchemas,
+      {},
+      schemaName
+    )
+
+  test('qualifies every table it creates', () => {
+    const sql = compilePg('app')
+    const creates = sql.match(/create table[^(]*/gi) ?? []
+
+    assert.ok(creates.length > 0, 'nothing was compiled')
+    for (const create of creates) {
+      assert.match(
+        create,
+        /"app"\./,
+        `unqualified create table in a schema-bound compile: ${create.trim()}`
+      )
+    }
+  })
+
+  test('qualifies foreign key targets, so they do not resolve by search path', () => {
+    const sql = compilePg('app')
+
+    assert.match(sql, /references "app"\./)
+    assert.doesNotMatch(
+      sql,
+      /references "(?!app")[^"]+" \(/,
+      'a foreign key onto an unqualified table would find whatever search_path points at'
+    )
+  })
+
+  /**
+   * The regression this option exists for.
+   *
+   * Raw SQL is passed through verbatim, so the expression index on `credentials`
+   * is the one statement `withSchema` cannot reach. Left unqualified it creates
+   * the uniqueness rule on a different table than the `create table` above it.
+   */
+  test('qualifies the raw expression index too', () => {
+    assert.match(
+      compilePg('app'),
+      /CREATE UNIQUE INDEX credentials_name_user_id_unique ON "app"\."credentials"/
+    )
+  })
+
+  test('leaves the index name itself unqualified', () => {
+    // An index belongs to the schema of the table it is on; postgres rejects a
+    // CREATE INDEX that says otherwise.
+    assert.doesNotMatch(compilePg('app'), /INDEX "?app"?\."?credentials_name/i)
+  })
+
+  test('compiles unqualified when no schema is asked for', () => {
+    const sql = compilePg()
+
+    assert.doesNotMatch(sql, /"app"\./)
+    assert.match(sql, /create table "credentials"/i)
+    assert.match(
+      sql,
+      /CREATE UNIQUE INDEX credentials_name_user_id_unique ON "credentials"/
+    )
+  })
+
+  test('does not qualify the connection it was handed', () => {
+    // The caller's connection is a scratch database the declaration was just
+    // applied to. Binding it would create tables in a schema that database has
+    // never heard of — so the schema must reach the SQL and nothing else.
+    const db = new Kysely<any>({ dialect: dialect('postgres') })
+    compilePikkuSchemas(db, pikkuSchemas, {}, 'app')
+
+    assert.match(
+      db.schema.createTable('after').addColumn('id', 'text').compile().sql,
+      /create table "after"/
+    )
+  })
+})

package/src/schema/scope.schema.ts

@@ -35,6 +35,20 @@ export const scopeSchema: PikkuSchema = {
         .createTable('pikkuRoles')
         .addColumn('name', 'text', (col) => col.primaryKey())
         .addColumn('description', 'text')
+        // Declared in code with `defineSystemRole` rather than composed by an
+        // admin. What it buys is the refusals: a system role cannot be renamed,
+        // re-scoped or deleted from the console, and a console role cannot be
+        // created with its name — two rows answering to one name would make
+        // "does Susan hold `buyer`?" depend on which one the store returned.
+        .addColumn('system', 'boolean', (col) => col.defaultTo(false).notNull())
+        // A system role whose declaration has gone: still held by whoever holds
+        // it, no longer offered for new grants, awaiting `pikku roles prune`.
+        // The same additive contract as `pikkuScopes.declared`, and for the same
+        // reason — a mid-deploy revocation is not something a code edit should
+        // be able to cause.
+        .addColumn('declared', 'boolean', (col) =>
+          col.defaultTo(true).notNull()
+        )
         .addColumn('createdAt', 'timestamp', (col) =>
           col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
         ),

package/src/schema/secret.schema.ts

@@ -27,6 +27,15 @@ export const secretSchema: PikkuSchema = {
           col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
         ),
 
+    (db) =>
+      db.schema
+        .createTable('secretKekSalts')
+        .addColumn('keyVersion', 'integer', (col) => col.primaryKey())
+        .addColumn('salt', 'varchar(64)', (col) => col.notNull())
+        .addColumn('createdAt', 'timestamp', (col) =>
+          col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
+        ),
+
     (db) =>
       db.schema
         .createTable('secretsAudit')

package/src/schema/virtual-user.schema.ts

@@ -0,0 +1,65 @@
+import { sql } from 'kysely'
+import type { PikkuSchema } from './pikku-schema.types.js'
+
+/**
+ * The `virtualUserRun` table {@link KyselyVirtualUserRunStore} writes to.
+ *
+ * Deliberately not in `pikkuSchemas`: the runtime never needs this table, only
+ * a project that runs virtual users does, and creating it for everyone would
+ * put an empty table in every database. `KyselyVirtualUserRunStore.init()`
+ * applies it, so it arrives exactly when the thing that fills it does.
+ *
+ * `persona` is text rather than a foreign key: personas are declared in code
+ * with `definePersonas()`, not rows, and a run has to outlive the deletion of
+ * the persona it ran as.
+ *
+ * The JSON columns are text on every engine, like the audit table's, because
+ * the store serialises them itself — a project on SQLite and one on Postgres
+ * then hold the same bytes, and comparing this week's findings against last
+ * week's does not depend on which database they were found in.
+ */
+export const virtualUserSchema: PikkuSchema = {
+  name: 'virtualUser',
+  statements: [
+    (db) =>
+      db.schema
+        .createTable('virtualUserRun')
+        .addColumn('runId', 'varchar(36)', (col) => col.primaryKey())
+        .addColumn('persona', 'varchar(255)', (col) => col.notNull())
+        .addColumn('disposition', 'varchar(50)', (col) => col.notNull())
+        .addColumn('seed', 'bigint', (col) => col.notNull())
+        // running | completed | failed. Not derived from `finishedAt` being
+        // null: a crashed run has no finish time either, and "crashed" and
+        // "still going" are not the same answer.
+        .addColumn('status', 'varchar(50)', (col) =>
+          col.defaultTo('running').notNull()
+        )
+        .addColumn('goals', 'text', (col) => col.defaultTo('[]').notNull())
+        .addColumn('memory', 'text', (col) => col.defaultTo('{}').notNull())
+        .addColumn('findings', 'text', (col) => col.defaultTo('[]').notNull())
+        // Counts the engine kept: steps, calls, mutations, tokens, elapsed.
+        .addColumn('tally', 'text')
+        .addColumn('stoppedBy', 'varchar(255)')
+        // Why the run itself failed, as opposed to what it found.
+        .addColumn('error', 'text')
+        .addColumn('startedBy', 'varchar(255)')
+        .addColumn('createdAt', 'timestamp', (col) =>
+          col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
+        )
+        .addColumn('finishedAt', 'timestamp'),
+
+    // The two reads: the run list newest-first, and one persona's history when
+    // a finding needs comparing against what that persona found before.
+    (db) =>
+      db.schema
+        .createIndex('idx_virtual_user_run_created')
+        .on('virtualUserRun')
+        .column('createdAt'),
+
+    (db) =>
+      db.schema
+        .createIndex('idx_virtual_user_run_persona')
+        .on('virtualUserRun')
+        .columns(['persona', 'createdAt']),
+  ],
+}