@pikku/kysely 0.13.23 → 0.13.27

package/src/schema/schema.test.ts

@@ -1,591 +0,0 @@
-import { test, describe } from 'node:test'
-import assert from 'node:assert/strict'
-import {
-  Kysely,
-  PostgresAdapter,
-  PostgresIntrospector,
-  PostgresQueryCompiler,
-  SqliteAdapter,
-  SqliteIntrospector,
-  SqliteQueryCompiler,
-  SqliteDialect,
-  DummyDriver,
-} from 'kysely'
-import Database from 'better-sqlite3'
-import {
-  pikkuSchemas,
-  requiredPikkuSchemas,
-  compilePikkuSchemas,
-  applyPikkuSchemas,
-  requirePikkuSchema,
-  declaredTables,
-  unsatisfiedRequirements,
-  type PikkuSchema,
-} from './index.js'
-import { workflowSchema } from './workflow.schema.js'
-
-const dialect = (kind: 'postgres' | 'sqlite') =>
-  kind === 'postgres'
-    ? {
-        createAdapter: () => new PostgresAdapter(),
-        createDriver: () => new DummyDriver(),
-        createIntrospector: (db: Kysely<any>) => new PostgresIntrospector(db),
-        createQueryCompiler: () => new PostgresQueryCompiler(),
-      }
-    : {
-        createAdapter: () => new SqliteAdapter(),
-        createDriver: () => new DummyDriver(),
-        createIntrospector: (db: Kysely<any>) => new SqliteIntrospector(db),
-        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) }))
-
-describe('pikku runtime schema', () => {
-  test('declares logical names and compiles them to physical ones', () => {
-    const sql = compileFor('postgres')
-
-    // The declaration says `agentThreads.resourceId`, matching how every query in
-    // the package addresses it; the plugin is what makes the table `agent_threads`.
-    assert.match(sql, /create table "agent_threads"/)
-    assert.match(sql, /"resource_id" varchar\(255\) not null/)
-    assert.doesNotMatch(
-      sql,
-      /"agentThreads"/,
-      'a camelCase table name means the plugin was not applied'
-    )
-  })
-
-  test('rewrites foreign key targets too', () => {
-    assert.match(
-      compileFor('postgres'),
-      /references "agent_threads" \("id"\)/,
-      'an unrewritten reference target points at a table that does not exist'
-    )
-  })
-
-  test('compiles for every dialect from the one declaration', () => {
-    for (const kind of ['postgres', 'sqlite'] as const) {
-      const sql = compileFor(kind)
-      assert.match(sql, /create table "workflow_runs"/, `${kind} workflow_runs`)
-      assert.match(sql, /create table "pikku_scopes"/, `${kind} pikku_scopes`)
-    }
-  })
-
-  test('carries the agent_run column the two old declarations disagreed on', () => {
-    assert.match(compileFor('postgres'), /"pending_approvals" text/)
-  })
-
-  test('creates tables outright rather than if-not-exists', () => {
-    // A migration runs once. `if not exists` would let a table that already
-    // exists in a different shape pass silently, which is the drift the
-    // migration is supposed to surface.
-    assert.doesNotMatch(compileFor('postgres'), /create table if not exists/)
-  })
-
-  test('drops the frozen uuid default from workflow primary keys', () => {
-    // It was `sql.raw("'" + crypto.randomUUID() + "'")`, evaluated once when the
-    // statement was built, so every row shared one default.
-    assert.match(
-      compileFor('postgres'),
-      /"workflow_run_id" text primary key,/,
-      'the primary key should carry no default at all'
-    )
-    assert.match(compileFor('postgres'), /"workflow_step_id" text primary key,/)
-    assert.match(compileFor('postgres'), /"history_id" text primary key,/)
-  })
-
-  test('every schema is named, for the migration it will be written into', () => {
-    const names = pikkuSchemas.map((s) => s.name)
-    assert.equal(new Set(names).size, names.length, 'names must be unique')
-    assert.ok(names.every((n) => /^[a-z][a-z-]*$/.test(n)))
-  })
-})
-
-describe('pikku runtime schema — prerequisites', () => {
-  const memoryDb = () =>
-    new Kysely<any>({
-      dialect: new SqliteDialect({ database: new Database(':memory:') }),
-    })
-
-  test('names the missing table and who owns it, before creating anything', async () => {
-    const db = memoryDb()
-    try {
-      await assert.rejects(
-        applyPikkuSchemas(db),
-        /The 'scope' schema requires 'user\.id', which nothing has created\. Better Auth owns it/
-      )
-
-      const created = await db.introspection.getTables()
-      assert.deepEqual(
-        created.map((t) => t.name),
-        [],
-        'a failed prerequisite must not leave a half-applied database'
-      )
-    } finally {
-      await db.destroy()
-    }
-  })
-
-  test('applies in full once the prerequisite is there', async () => {
-    const db = memoryDb()
-    try {
-      await db.schema
-        .createTable('user')
-        .addColumn('id', 'text', (col) => col.primaryKey())
-        .execute()
-
-      assert.deepEqual(await unsatisfiedRequirements(db), [])
-      await applyPikkuSchemas(db)
-
-      const created = new Set(
-        (await db.introspection.getTables()).map((t) => t.name)
-      )
-      assert.ok(created.has('pikku_user_role'))
-      assert.ok(created.has('workflow_runs'))
-    } finally {
-      await db.destroy()
-    }
-  })
-
-  test('takes the grant column type from the user id it references', () => {
-    // The hand-written DDL said `text`. Better Auth generates a `uuid` primary
-    // key on postgres, and postgres rejects a text column referencing it —
-    // which is why projects ended up writing these tables by hand.
-    const sql = compilePikkuSchemas(
-      new Kysely<any>({ dialect: dialect('postgres') }),
-      pikkuSchemas,
-      { 'user.id': 'uuid' }
-    )
-    assert.match(
-      sql,
-      /create table "pikku_user_role" \("user_id" uuid not null references "user" \("id"\)/
-    )
-    assert.match(
-      sql,
-      /create table "pikku_user_scope" \("user_id" uuid not null references "user" \("id"\)/
-    )
-  })
-
-  test('reports the gap as data, so a caller can describe it instead of dying', async () => {
-    const db = memoryDb()
-    try {
-      const unmet = await unsatisfiedRequirements(db)
-      assert.deepEqual(
-        unmet.map(({ schema, requirement }) => ({
-          schema: schema.name,
-          ...requirement,
-        })),
-        [{ schema: 'scope', table: 'user', column: 'id', owner: 'Better Auth' }]
-      )
-
-      // The rest of the declaration does not depend on auth, so it still applies.
-      const satisfiable = pikkuSchemas.filter((s) => s.name !== 'scope')
-      await applyPikkuSchemas(db, satisfiable)
-      const created = new Set(
-        (await db.introspection.getTables()).map((t) => t.name)
-      )
-      assert.ok(created.has('workflow_runs'))
-      assert.equal(created.has('pikku_user_role'), false)
-    } finally {
-      await db.destroy()
-    }
-  })
-
-  test('a statement failing part way takes the ones before it with it', async () => {
-    const db = memoryDb()
-    try {
-      await db.schema.createTable('taken').addColumn('id', 'text').execute()
-
-      // The prerequisite check cannot see this coming: nothing is missing, the
-      // second statement simply collides with a table the database already has.
-      const collides: PikkuSchema = {
-        name: 'collides',
-        statements: [
-          (db) => db.schema.createTable('first').addColumn('id', 'text'),
-          (db) => db.schema.createTable('taken').addColumn('id', 'text'),
-        ],
-      }
-
-      await assert.rejects(applyPikkuSchemas(db, [collides]))
-
-      const created = new Set(
-        (await db.introspection.getTables()).map((t) => t.name)
-      )
-      assert.equal(
-        created.has('first'),
-        false,
-        'the statement that succeeded must roll back with the one that did not'
-      )
-    } finally {
-      await db.destroy()
-    }
-  })
-})
-
-describe('requirePikkuSchema — what a service does at boot', () => {
-  const memoryDb = () =>
-    new Kysely<any>({
-      dialect: new SqliteDialect({ database: new Database(':memory:') }),
-    })
-
-  test('refuses a database the migration never reached, naming the command', async () => {
-    const db = memoryDb()
-    try {
-      await assert.rejects(
-        requirePikkuSchema(db, workflowSchema),
-        /The 'workflow' schema is not in this database.*pikku db generate/s
-      )
-    } finally {
-      await db.destroy()
-    }
-  })
-
-  test('creates nothing on the way to that refusal', async () => {
-    // The whole point: a service that finds its tables missing stops, and the
-    // database it stopped against is exactly as it was.
-    const db = memoryDb()
-    try {
-      await assert.rejects(requirePikkuSchema(db, workflowSchema))
-      const tables = await db.introspection.getTables()
-      assert.deepEqual(tables, [])
-    } finally {
-      await db.destroy()
-    }
-  })
-
-  test('two services declaring the same schema do not fight over it', async () => {
-    // The workflow service and the workflow mirror both own these tables, and
-    // both call init(). Neither creates anything, so both find the migrated
-    // tables and return.
-    const db = memoryDb()
-    try {
-      await applyPikkuSchemas(db, [workflowSchema])
-      await assert.doesNotReject(requirePikkuSchema(db, workflowSchema))
-      await assert.doesNotReject(requirePikkuSchema(db, workflowSchema))
-    } finally {
-      await db.destroy()
-    }
-  })
-
-  test('a half-applied schema is refused the same way a missing one is', async () => {
-    // Something else already owns part of it — a migration, an older release,
-    // a hand-run script. Half-present is not a distinct case: the remedy is the
-    // same migration either way, so the sentence names both halves and stops.
-    const db = memoryDb()
-    try {
-      await db.schema
-        .createTable('workflow_runs')
-        .addColumn('workflow_run_id', 'text', (col) => col.primaryKey())
-        .execute()
-
-      await assert.rejects(
-        requirePikkuSchema(db, workflowSchema),
-        /workflow_step.*missing.*workflow_runs already there/s
-      )
-    } finally {
-      await db.destroy()
-    }
-  })
-})
-
-describe('requirePikkuSchema — 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 `requirePikkuSchema` 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 }))
-    )
-
-    await assert.doesNotReject(
-      requirePikkuSchema(db.withSchema('app'), workflowSchema)
-    )
-  })
-
-  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 }))
-    )
-
-    await assert.rejects(
-      requirePikkuSchema(db.withSchema('app'), workflowSchema),
-      /is not in this database/
-    )
-  })
-
-  test('still matches on the bare name when the connection is unbound', async () => {
-    const db = introspecting(
-      WORKFLOW_TABLES.map((name) => ({ schema: 'public', name }))
-    )
-
-    await assert.doesNotReject(requirePikkuSchema(db, workflowSchema))
-  })
-
-  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 }))
-    )
-
-    await assert.doesNotReject(
-      requirePikkuSchema(db.withSchema('main'), workflowSchema)
-    )
-  })
-
-  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(
-      applyPikkuSchemas(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(
-        applyPikkuSchemas(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(
-      requirePikkuSchema(db.withSchema('app'), workflowSchema),
-      /app\.workflow_step.*missing.*app\.workflow_runs already there/s
-    )
-  })
-})
-
-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"/
-    )
-  })
-})
-
-describe('requiredPikkuSchemas', () => {
-  test('a project that reaches no service still gets the ungated schemas', () => {
-    const names = requiredPikkuSchemas(new Set()).map((s) => s.name)
-    assert.deepEqual(names, ['session', 'secret', 'deployment'])
-  })
-
-  test('a service brings in its own schema, in the declared order', () => {
-    const names = requiredPikkuSchemas(
-      new Set(['channelStore', 'workflowService'])
-    ).map((s) => s.name)
-    assert.deepEqual(names, [
-      'channel',
-      'session',
-      'secret',
-      'deployment',
-      'workflow',
-    ])
-  })
-
-  test('any one of a schema s owners is enough to ask for it', () => {
-    // A schema several services share is needed as soon as one of them is.
-    assert.ok(
-      requiredPikkuSchemas(new Set(['workflowRunService'])).some(
-        (s) => s.name === 'workflow'
-      )
-    )
-    assert.ok(
-      requiredPikkuSchemas(new Set(['eventHub'])).some(
-        (s) => s.name === 'channel'
-      )
-    )
-  })
-
-  test('naming every owner asks for everything', () => {
-    const owners = pikkuSchemas.flatMap((s) => s.ownedBy ?? [])
-    assert.equal(
-      requiredPikkuSchemas(new Set(owners)).length,
-      pikkuSchemas.length
-    )
-  })
-})

package/src/schema/scope.schema.ts

@@ -1,110 +0,0 @@
-import { sql } from 'kysely'
-import { requiredType, type PikkuSchema } from './pikku-schema.types.js'
-
-/**
- * Scopes, roles and the grants that bind them to users.
- *
- * `pikkuUserRole` and `pikkuUserScope` reference `user.id`, which Better Auth
- * owns. Auth is a prerequisite rather than an optional companion: a grant is
- * made to a user, so without the table the user lives in there is nothing to
- * grant to, and the cascade that revokes grants when a user is deleted has
- * nothing to hang off.
- *
- * `userId` takes its type from `user.id` rather than declaring one, because
- * that type is Better Auth's to decide: `text` by default, `uuid` under
- * `generateId: 'uuid'`, an identity `integer` under `'serial'`. The old
- * hand-written DDL said `text`, and postgres rejects a `text` column
- * referencing either of the others — so the whole statement failed and projects
- * wrote these tables by hand instead.
- */
-export const scopeSchema: PikkuSchema = {
-  name: 'scope',
-  ownedBy: ['scopeService'],
-  requires: [{ table: 'user', column: 'id', owner: 'Better Auth' }],
-  statements: [
-    (db) =>
-      db.schema
-        .createTable('pikkuScopes')
-        .addColumn('name', 'text', (col) => col.primaryKey())
-        .addColumn('description', 'text')
-        .addColumn('declared', 'boolean', (col) =>
-          col.defaultTo(true).notNull()
-        ),
-
-    (db) =>
-      db.schema
-        .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()
-        ),
-
-    (db) =>
-      db.schema
-        .createTable('pikkuRoleScopes')
-        .addColumn('role', 'text', (col) =>
-          col.notNull().references('pikkuRoles.name').onDelete('cascade')
-        )
-        .addColumn('scope', 'text', (col) =>
-          col.notNull().references('pikkuScopes.name').onDelete('cascade')
-        )
-        .addPrimaryKeyConstraint('pikku_role_scopes_pk', ['role', 'scope']),
-
-    (db, types) =>
-      db.schema
-        .createTable('pikkuUserRole')
-        .addColumn('userId', requiredType(types, 'user', 'id'), (col) =>
-          col.notNull().references('user.id').onDelete('cascade')
-        )
-        .addColumn('role', 'text', (col) =>
-          col.notNull().references('pikkuRoles.name').onDelete('cascade')
-        )
-        .addColumn('grantedBy', 'text')
-        .addColumn('grantedAt', 'timestamp', (col) =>
-          col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
-        )
-        .addPrimaryKeyConstraint('pikku_user_role_pk', ['userId', 'role']),
-
-    (db, types) =>
-      db.schema
-        .createTable('pikkuUserScope')
-        .addColumn('userId', requiredType(types, 'user', 'id'), (col) =>
-          col.notNull().references('user.id').onDelete('cascade')
-        )
-        .addColumn('scope', 'text', (col) =>
-          col.notNull().references('pikkuScopes.name').onDelete('cascade')
-        )
-        .addColumn('grantedBy', 'text')
-        .addColumn('grantedAt', 'timestamp', (col) =>
-          col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
-        )
-        .addPrimaryKeyConstraint('pikku_user_scope_pk', ['userId', 'scope']),
-
-    (db) =>
-      db.schema
-        .createIndex('pikku_role_scopes_scope_idx')
-        .on('pikkuRoleScopes')
-        .column('scope'),
-
-    (db) =>
-      db.schema
-        .createIndex('pikku_user_role_role_idx')
-        .on('pikkuUserRole')
-        .column('role'),
-  ],
-}