@pikku/kysely 0.13.4 → 0.13.6

package/src/schema/schema.test.ts

@@ -17,6 +17,7 @@ import {
   compilePikkuSchemas,
   applyPikkuSchemas,
   ensurePikkuSchema,
+  declaredTables,
   unsatisfiedRequirements,
   type PikkuSchema,
 } from './index.js'
@@ -37,6 +38,21 @@ const dialect = (kind: 'postgres' | 'sqlite') =>
         createQueryCompiler: () => new SqliteQueryCompiler(),
       }
 
+/** A driver whose every query fails with `error` — for testing the failure path. */
+class ThrowingDriver extends DummyDriver {
+  constructor(private readonly error: Error) {
+    super()
+  }
+  override async acquireConnection() {
+    return {
+      executeQuery: async (): Promise<never> => {
+        throw this.error
+      },
+      streamQuery: async function* () {},
+    }
+  }
+}
+
 const compileFor = (kind: 'postgres' | 'sqlite') =>
   compilePikkuSchemas(new Kysely<any>({ dialect: dialect(kind) }))
 
@@ -271,3 +287,170 @@ describe('ensurePikkuSchema — what a service does at boot', () => {
     }
   })
 })
+
+describe('ensurePikkuSchema — a connection bound to a schema', () => {
+  const WORKFLOW_TABLES = [
+    'workflow_runs',
+    'workflow_step',
+    'workflow_step_history',
+    'workflow_versions',
+  ]
+
+  /**
+   * A postgres connection whose introspection answers with `tables`.
+   *
+   * Stubbed rather than run against a real database because sqlite has one
+   * schema and nothing else here speaks postgres — and introspection is the
+   * only thing `ensurePikkuSchema` reads before it decides. DummyDriver takes
+   * whatever DDL follows.
+   */
+  const introspecting = (
+    tables: Array<{ schema: string | undefined; name: string }>
+  ) =>
+    new Kysely<any>({
+      dialect: {
+        ...dialect('postgres'),
+        createIntrospector: () => ({
+          getSchemas: async () => [],
+          getMetadata: async () => ({ tables: [] }),
+          getTables: async () =>
+            tables.map(({ schema, name }) => ({
+              schema,
+              name,
+              isView: false,
+              columns: [],
+            })),
+        }),
+      },
+    })
+
+  test('reads the schema out of its own DDL, not the table name', () => {
+    const db = new Kysely<any>({ dialect: dialect('postgres') })
+
+    assert.deepEqual(declaredTables(workflowSchema, db.withSchema('app')), [
+      { schema: 'app', name: 'workflow_runs' },
+      { schema: 'app', name: 'workflow_step' },
+      { schema: 'app', name: 'workflow_step_history' },
+      { schema: 'app', name: 'workflow_versions' },
+    ])
+
+    // Unqualified DDL resolves against the connection's search_path, which is
+    // not knowable from here — so there is no schema to report.
+    assert.deepEqual(
+      declaredTables(workflowSchema, db),
+      WORKFLOW_TABLES.map((name) => ({ schema: undefined, name }))
+    )
+  })
+
+  test('finds tables that already exist under that schema', async () => {
+    // The regression this exists for: a `withSchema('app')` connection reading
+    // its own `create table "app"."workflow_runs"` as a table called `app`,
+    // concluding every table was missing, and issuing a bare CREATE that the
+    // database rejects with `relation "workflow_runs" already exists` — on
+    // every boot, forever.
+    const db = introspecting(
+      WORKFLOW_TABLES.map((name) => ({ schema: 'app', name }))
+    )
+
+    assert.equal(
+      await ensurePikkuSchema(db.withSchema('app'), workflowSchema),
+      'present'
+    )
+  })
+
+  test('does not accept the same names in a different schema', async () => {
+    // `withSchema('app')` reads and writes `app.workflow_runs`. A
+    // `public.workflow_runs` is a different table and answers nothing.
+    const db = introspecting(
+      WORKFLOW_TABLES.map((name) => ({ schema: 'public', name }))
+    )
+
+    assert.equal(
+      await ensurePikkuSchema(db.withSchema('app'), workflowSchema),
+      'created'
+    )
+  })
+
+  test('still matches on the bare name when the connection is unbound', async () => {
+    const db = introspecting(
+      WORKFLOW_TABLES.map((name) => ({ schema: 'public', name }))
+    )
+
+    assert.equal(await ensurePikkuSchema(db, workflowSchema), 'present')
+  })
+
+  test('matches on the bare name when the engine reports no schemas', async () => {
+    // sqlite and mysql leave `TableMetadata.schema` unset. Holding out for the
+    // qualified pair there would read every existing table as missing — the
+    // same false negative this suite exists for, arrived at from the other side.
+    const db = introspecting(
+      WORKFLOW_TABLES.map((name) => ({ schema: undefined, name }))
+    )
+
+    assert.equal(
+      await ensurePikkuSchema(db.withSchema('main'), workflowSchema),
+      'present'
+    )
+  })
+
+  test('leaves a syntax error that is not sqlite refusing a qualifier alone', async () => {
+    // Postgres compiles the same qualified reference legitimately, and can
+    // 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 db = new Kysely<any>({
+      dialect: {
+        ...dialect('postgres'),
+        createDriver: () => new ThrowingDriver(pgError),
+        createIntrospector: () => ({
+          getSchemas: async () => [],
+          getMetadata: async () => ({ tables: [] }),
+          getTables: async () => [],
+        }),
+      },
+    })
+
+    await assert.rejects(
+      ensurePikkuSchema(db.withSchema('app'), workflowSchema),
+      (error: Error) => {
+        assert.equal(error, pgError, 'the engine error must pass through as-is')
+        return true
+      }
+    )
+  })
+
+  test('explains the qualified foreign key sqlite cannot express', async () => {
+    // `withSchema` qualifies foreign key targets too. Postgres needs that;
+    // sqlite refuses it, and says only `near ".": syntax error` — which names
+    // neither the schema nor the connection that produced it.
+    const db = new Kysely<any>({
+      dialect: new SqliteDialect({ database: new Database(':memory:') }),
+    })
+    try {
+      await assert.rejects(
+        ensurePikkuSchema(db.withSchema('main'), workflowSchema),
+        (error: Error) => {
+          assert.match(error.message, /bound to a schema/)
+          assert.match(error.message, /takes a bare table name/i)
+          assert.ok(error.cause, 'the engine error must survive as the cause')
+          return true
+        }
+      )
+    } finally {
+      await db.destroy()
+    }
+  })
+
+  test('names the schema when it reports a half-applied one', async () => {
+    const db = introspecting([{ schema: 'app', name: 'workflow_runs' }])
+
+    await assert.rejects(
+      ensurePikkuSchema(db.withSchema('app'), workflowSchema),
+      /app\.workflow_step.*missing.*app\.workflow_runs already there/s
+    )
+  })
+})

package/src/schema/workflow.schema.ts

@@ -8,8 +8,10 @@ import type { PikkuSchema } from './pikku-schema.types.js'
  * primary keys had `defaultTo(sql.raw("'" + crypto.randomUUID() + "'"))`, which
  * evaluates once while the statement is built — every row would have taken the
  * same default, so it was never a generator; the services supply the id. And
- * `workflowStep.fromStepName` was backfilled by an `alterTable(...).catch(() =>
- * {})` bolted on after the fact, which is the job a migration does.
+ * `workflowStep.fromStepName`, `workflowStep.currentAttempt` and
+ * `workflowStepHistory.attempt` were each backfilled by an
+ * `alterTable(...).catch(() => {})` bolted on after the fact, which is the job a
+ * migration does — they are declared here and nowhere else.
  *
  * `KyselyWorkflowMirror` created these same four tables separately. There is one
  * declaration now, and both services read it.
@@ -62,6 +64,7 @@ export const workflowSchema: PikkuSchema = {
         .addColumn('retries', 'integer')
         .addColumn('retryDelay', 'text')
         .addColumn('fromStepName', 'text')
+        .addColumn('currentAttempt', 'integer')
         .addColumn('createdAt', 'timestamp', (col) =>
           col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
         )
@@ -86,6 +89,7 @@ export const workflowSchema: PikkuSchema = {
         .addColumn('status', 'text', (col) => col.notNull())
         .addColumn('result', 'text')
         .addColumn('error', 'text')
+        .addColumn('attempt', 'integer')
         .addColumn('createdAt', 'timestamp', (col) =>
           col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
         )
@@ -109,5 +113,37 @@ export const workflowSchema: PikkuSchema = {
           'workflowName',
           'graphHash',
         ]),
+
+    // The indexes trail the tables so that a table is never indexed before it
+    // exists, whatever order the declarations are read in.
+    (db) =>
+      db.schema
+        .createIndex('idx_workflow_runs_status_created')
+        .on('workflowRuns')
+        .columns(['status', 'createdAt']),
+
+    (db) =>
+      db.schema
+        .createIndex('idx_workflow_runs_workflow_created')
+        .on('workflowRuns')
+        .columns(['workflow', 'createdAt']),
+
+    (db) =>
+      db.schema
+        .createIndex('idx_workflow_step_run_status')
+        .on('workflowStep')
+        .columns(['workflowRunId', 'status']),
+
+    (db) =>
+      db.schema
+        .createIndex('idx_workflow_step_history_step')
+        .on('workflowStepHistory')
+        .columns(['workflowStepId', 'createdAt']),
+
+    (db) =>
+      db.schema
+        .createIndex('idx_workflow_versions_source_status')
+        .on('workflowVersions')
+        .columns(['source', 'status']),
   ],
 }