create-monolayer-app 0.1.1 → 0.2.0

package/template/vendor/kysely-dsql/dsql/query-compiler.test.ts

@@ -0,0 +1,765 @@
+// oxlint-disable max-classes-per-file typescript/no-explicit-any
+import {
+  AddColumnNode,
+  AddConstraintNode,
+  CheckConstraintNode,
+  ColumnDefinitionNode,
+  ColumnNode,
+  DataTypeNode,
+  DefaultValueNode,
+  ForeignKeyConstraintNode,
+  GeneratedNode,
+  IdentifierNode,
+  Kysely,
+  OrderByItemNode,
+  PostgresIntrospector,
+  RawNode,
+  ReferencesNode,
+  SchemableIdentifierNode,
+  SelectQueryNode,
+  TableNode,
+  ValueNode,
+  sql,
+} from "kysely";
+import type {
+  AlterColumnNode,
+  AlterTypeNode,
+  CreateIndexNode,
+  CreateTableNode,
+  CreateTypeNode,
+  CreateViewNode,
+  DatabaseConnection,
+  Dialect,
+  DialectAdapter,
+  Driver,
+  DropTypeNode,
+  DropViewNode,
+  ModifyColumnNode,
+  OperationNode,
+  QueryResult,
+  RefreshMaterializedViewNode,
+  RootOperationNode,
+  TransactionSettings,
+} from "kysely";
+import { describe, expect, it, vi } from "vitest";
+
+import { DQSLAdapter } from "./adapter.js";
+import { DSQLQueryCompilerError } from "./query-compiler-error.js";
+import { DSQLQueryCompiler } from "./query-compiler.js";
+
+const compileNode = (node: OperationNode): string => {
+  const compiler = new DSQLQueryCompiler();
+  // SAFETY: OperationNode is cast to RootOperationNode for isolated node compilation testing.
+  const rootNode = node as RootOperationNode;
+  const compiled = compiler.compileQuery(rootNode, {
+    queryId: "test-query-id",
+  });
+  return compiled.sql;
+};
+
+class SpyDriver implements Driver {
+  readonly acquireConnection = vi.fn<() => Promise<DatabaseConnection>>();
+  readonly beginTransaction =
+    vi.fn<
+      (
+        connection: DatabaseConnection,
+        settings: TransactionSettings
+      ) => Promise<void>
+    >();
+  readonly commitTransaction =
+    vi.fn<(connection: DatabaseConnection) => Promise<void>>();
+  readonly rollbackTransaction =
+    vi.fn<(connection: DatabaseConnection) => Promise<void>>();
+  readonly releaseConnection =
+    vi.fn<(connection: DatabaseConnection) => Promise<void>>();
+  readonly destroy = vi.fn<() => Promise<void>>();
+  readonly init = vi.fn<() => Promise<void>>().mockResolvedValue();
+}
+
+class SpyDialect implements Dialect {
+  readonly driver: SpyDriver;
+
+  constructor(driver: SpyDriver) {
+    this.driver = driver;
+  }
+
+  createDriver(): Driver {
+    return this.driver;
+  }
+
+  // oxlint-disable-next-line class-methods-use-this
+  createQueryCompiler(): DSQLQueryCompiler {
+    return new DSQLQueryCompiler();
+  }
+
+  // oxlint-disable-next-line class-methods-use-this
+  createAdapter(): DialectAdapter {
+    return new DQSLAdapter();
+  }
+
+  // oxlint-disable-next-line class-methods-use-this
+  createIntrospector(database: Kysely<any>): PostgresIntrospector {
+    return new PostgresIntrospector(database);
+  }
+}
+
+const createTestDb = (driver: SpyDriver): Kysely<any> =>
+  new Kysely<any>({
+    dialect: new SpyDialect(driver),
+  });
+
+describe(DSQLQueryCompilerError, () => {
+  it("constructs an error with issues metadata", () => {
+    const error = new DSQLQueryCompilerError([
+      {
+        code: "foreign_key",
+        feature: "Foreign key constraints",
+        message: "Aurora DSQL does not support foreign key constraints.",
+        documentationUrl:
+          "https://docs.aws.amazon.com/aurora-dsql/latest/userguide/create-table-syntax-support.html",
+      },
+    ]);
+
+    expect(error.name).toBe("DSQLQueryCompilerError");
+    expect(error.issues).toHaveLength(1);
+    expect(error.issues[0]?.code).toBe("foreign_key");
+  });
+
+  it("does not expose SQL text in the error message", () => {
+    const error = new DSQLQueryCompilerError([
+      {
+        code: "foreign_key",
+        feature: "Foreign key constraints",
+        message: "Aurora DSQL does not support foreign key constraints.",
+        documentationUrl:
+          "https://docs.aws.amazon.com/aurora-dsql/latest/userguide/create-table-syntax-support.html",
+      },
+    ]);
+
+    expect(error.message).toContain("[foreign_key]");
+    expect(error.message).not.toContain("SELECT");
+    expect(error.message).not.toContain("CREATE TABLE");
+  });
+});
+
+describe(DSQLQueryCompiler, () => {
+  describe("compileQuery SQL backstop validation", () => {
+    it("throws DSQLQueryCompilerError for unsupported raw SQL", () => {
+      const compiler = new DSQLQueryCompiler();
+      const node = RawNode.createWithSql("TRUNCATE TABLE users;");
+      // SAFETY: RawNode is cast to RootOperationNode for compiler testing.
+      const rootNode = node as RootOperationNode;
+
+      expect(() => compiler.compileQuery(rootNode, { queryId: "q1" })).toThrow(
+        DSQLQueryCompilerError
+      );
+    });
+
+    it("does not expose SQL in compiler error message", () => {
+      const compiler = new DSQLQueryCompiler();
+      const node = RawNode.createWithSql("TRUNCATE TABLE users;");
+      // SAFETY: RawNode is cast to RootOperationNode for compiler testing.
+      const rootNode = node as RootOperationNode;
+
+      let caughtError: DSQLQueryCompilerError | null = null;
+      try {
+        compiler.compileQuery(rootNode, { queryId: "q1" });
+      } catch (error) {
+        if (error instanceof DSQLQueryCompilerError) {
+          caughtError = error;
+        }
+      }
+
+      expect(caughtError).not.toBeNull();
+      expect(
+        caughtError?.issues.some((issue) => issue.code === "truncate")
+      ).toBeTruthy();
+      expect(caughtError?.message).not.toContain("TRUNCATE TABLE users");
+    });
+
+    it("compiles supported raw queries successfully", () => {
+      const compiler = new DSQLQueryCompiler();
+      const node = RawNode.createWithSql("SELECT 1");
+      // SAFETY: RawNode is cast to RootOperationNode for compiler testing.
+      const rootNode = node as RootOperationNode;
+      const compiled = compiler.compileQuery(rootNode, { queryId: "q2" });
+      expect(compiled.sql).toBe("SELECT 1");
+    });
+  });
+
+  describe("structured CREATE TABLE guards", () => {
+    it("rejects temporary tables", () => {
+      const node: CreateTableNode = {
+        kind: "CreateTableNode",
+        table: TableNode.create("temp_users"),
+        columns: [
+          ColumnDefinitionNode.create("id", DataTypeNode.create("uuid")),
+        ],
+        temporary: true,
+      };
+      expect(() => compileNode(node)).toThrow(DSQLQueryCompilerError);
+    });
+
+    it("rejects onCommit actions", () => {
+      const node: CreateTableNode = {
+        kind: "CreateTableNode",
+        table: TableNode.create("temp_users"),
+        columns: [
+          ColumnDefinitionNode.create("id", DataTypeNode.create("uuid")),
+        ],
+        onCommit: "drop",
+      };
+      expect(() => compileNode(node)).toThrow(DSQLQueryCompilerError);
+    });
+
+    it("rejects CREATE TABLE AS (selectQuery)", () => {
+      const node: CreateTableNode = {
+        kind: "CreateTableNode",
+        table: TableNode.create("user_copy"),
+        columns: [],
+        selectQuery: SelectQueryNode.create(),
+      };
+      expect(() => compileNode(node)).toThrow(DSQLQueryCompilerError);
+    });
+
+    it("rejects inline indexes inside CREATE TABLE", () => {
+      // SAFETY: Cast mock index node to AddIndexNode array for test assertion.
+      const mockIndex = {
+        kind: "AddIndexNode",
+        columns: [ColumnNode.create("id")],
+      } as any;
+      const node: CreateTableNode = {
+        kind: "CreateTableNode",
+        table: TableNode.create("users"),
+        columns: [
+          ColumnDefinitionNode.create("id", DataTypeNode.create("uuid")),
+        ],
+        indexes: [mockIndex],
+      };
+      expect(() => compileNode(node)).toThrow(DSQLQueryCompilerError);
+    });
+
+    it("rejects foreign key constraints inside CREATE TABLE", () => {
+      const node: CreateTableNode = {
+        kind: "CreateTableNode",
+        table: TableNode.create("orders"),
+        columns: [
+          ColumnDefinitionNode.create("id", DataTypeNode.create("uuid")),
+        ],
+        constraints: [
+          ForeignKeyConstraintNode.create(
+            [ColumnNode.create("user_id")],
+            TableNode.create("users"),
+            [ColumnNode.create("id")]
+          ),
+        ],
+      };
+      expect(() => compileNode(node)).toThrow(DSQLQueryCompilerError);
+    });
+  });
+
+  describe("structured ColumnDefinition guards", () => {
+    it("rejects references on column definition", () => {
+      const node = ColumnDefinitionNode.cloneWith(
+        ColumnDefinitionNode.create("user_id", DataTypeNode.create("uuid")),
+        {
+          references: ReferencesNode.create(TableNode.create("users"), [
+            ColumnNode.create("id"),
+          ]),
+        }
+      );
+      const tableNode: CreateTableNode = {
+        kind: "CreateTableNode",
+        table: TableNode.create("orders"),
+        columns: [node],
+      };
+      expect(() => compileNode(tableNode)).toThrow(DSQLQueryCompilerError);
+    });
+
+    it("rejects autoIncrement on column definition", () => {
+      const node = ColumnDefinitionNode.cloneWith(
+        ColumnDefinitionNode.create("id", DataTypeNode.create("integer")),
+        { autoIncrement: true }
+      );
+      const tableNode: CreateTableNode = {
+        kind: "CreateTableNode",
+        table: TableNode.create("users"),
+        columns: [node],
+      };
+      expect(() => compileNode(tableNode)).toThrow(DSQLQueryCompilerError);
+    });
+
+    it("rejects identity on column definition", () => {
+      const node = ColumnDefinitionNode.cloneWith(
+        ColumnDefinitionNode.create("id", DataTypeNode.create("bigint")),
+        { identity: true }
+      );
+      const tableNode: CreateTableNode = {
+        kind: "CreateTableNode",
+        table: TableNode.create("users"),
+        columns: [node],
+      };
+      expect(() => compileNode(tableNode)).toThrow(DSQLQueryCompilerError);
+    });
+  });
+
+  describe("structured CREATE/DROP/REFRESH VIEW guards", () => {
+    it("rejects temporary views", () => {
+      const node: CreateViewNode = {
+        kind: "CreateViewNode",
+        name: SchemableIdentifierNode.create("temp_view"),
+        temporary: true,
+      };
+      expect(() => compileNode(node)).toThrow(DSQLQueryCompilerError);
+    });
+
+    it("rejects materialized views in createView", () => {
+      const node: CreateViewNode = {
+        kind: "CreateViewNode",
+        name: SchemableIdentifierNode.create("mat_view"),
+        materialized: true,
+      };
+      expect(() => compileNode(node)).toThrow(DSQLQueryCompilerError);
+    });
+
+    it("rejects materialized views in dropView", () => {
+      const node: DropViewNode = {
+        kind: "DropViewNode",
+        name: SchemableIdentifierNode.create("mat_view"),
+        materialized: true,
+      };
+      expect(() => compileNode(node)).toThrow(DSQLQueryCompilerError);
+    });
+
+    it("rejects refresh materialized view", () => {
+      const node: RefreshMaterializedViewNode = {
+        kind: "RefreshMaterializedViewNode",
+        name: SchemableIdentifierNode.create("mat_view"),
+      };
+      expect(() => compileNode(node)).toThrow(DSQLQueryCompilerError);
+    });
+
+    it("compiles supported views", () => {
+      const createNode: CreateViewNode = {
+        kind: "CreateViewNode",
+        name: SchemableIdentifierNode.create("active_users"),
+        orReplace: true,
+        as: RawNode.createWithSql("SELECT id FROM users"),
+      };
+      expect(compileNode(createNode)).toBe(
+        'create or replace view "active_users" as SELECT id FROM users'
+      );
+
+      const dropNode: DropViewNode = {
+        kind: "DropViewNode",
+        name: SchemableIdentifierNode.create("active_users"),
+      };
+      expect(compileNode(dropNode)).toBe('drop view "active_users"');
+    });
+  });
+
+  describe("structured Type guards", () => {
+    it("rejects createType", () => {
+      const node: CreateTypeNode = {
+        kind: "CreateTypeNode",
+        name: SchemableIdentifierNode.create("status_enum"),
+      };
+      expect(() => compileNode(node)).toThrow(DSQLQueryCompilerError);
+    });
+
+    it("rejects dropType", () => {
+      const node: DropTypeNode = {
+        kind: "DropTypeNode",
+        name: SchemableIdentifierNode.create("status_enum"),
+      };
+      expect(() => compileNode(node)).toThrow(DSQLQueryCompilerError);
+    });
+
+    it("rejects alterType", () => {
+      const node: AlterTypeNode = {
+        kind: "AlterTypeNode",
+        name: SchemableIdentifierNode.create("status_enum"),
+      };
+      expect(() => compileNode(node)).toThrow(DSQLQueryCompilerError);
+    });
+  });
+
+  describe("structured Foreign Key and References visitor guards", () => {
+    it("rejects visitForeignKeyConstraint directly", () => {
+      const node = ForeignKeyConstraintNode.create(
+        [ColumnNode.create("user_id")],
+        TableNode.create("users"),
+        [ColumnNode.create("id")]
+      );
+      expect(() => compileNode(node)).toThrow(DSQLQueryCompilerError);
+    });
+
+    it("rejects visitReferences directly", () => {
+      const node = ReferencesNode.create(TableNode.create("users"), [
+        ColumnNode.create("id"),
+      ]);
+      expect(() => compileNode(node)).toThrow(DSQLQueryCompilerError);
+    });
+  });
+
+  describe("structured ALTER TABLE column modification guards", () => {
+    it("rejects visitModifyColumn", () => {
+      const node: ModifyColumnNode = {
+        kind: "ModifyColumnNode",
+        column: ColumnDefinitionNode.create(
+          "age",
+          DataTypeNode.create("integer")
+        ),
+      };
+      expect(() => compileNode(node)).toThrow(DSQLQueryCompilerError);
+    });
+
+    it("rejects altering column type", () => {
+      const node: AlterColumnNode = {
+        kind: "AlterColumnNode",
+        column: ColumnNode.create("age"),
+        dataType: DataTypeNode.create("bigint"),
+      };
+      expect(() => compileNode(node)).toThrow(DSQLQueryCompilerError);
+    });
+
+    it("rejects altering column type with expression", () => {
+      const node: AlterColumnNode = {
+        kind: "AlterColumnNode",
+        column: ColumnNode.create("age"),
+        dataTypeExpression: RawNode.createWithSql("bigint"),
+      };
+      expect(() => compileNode(node)).toThrow(DSQLQueryCompilerError);
+    });
+
+    it("rejects altering column SET NOT NULL", () => {
+      const node: AlterColumnNode = {
+        kind: "AlterColumnNode",
+        column: ColumnNode.create("age"),
+        setNotNull: true,
+      };
+      expect(() => compileNode(node)).toThrow(DSQLQueryCompilerError);
+    });
+
+    it("compiles supported alter column actions: drop not null, set default, drop default", () => {
+      const dropNotNull: AlterColumnNode = {
+        kind: "AlterColumnNode",
+        column: ColumnNode.create("age"),
+        dropNotNull: true,
+      };
+      expect(compileNode(dropNotNull)).toBe('alter column "age" drop not null');
+
+      const setDefault: AlterColumnNode = {
+        kind: "AlterColumnNode",
+        column: ColumnNode.create("status"),
+        setDefault: ValueNode.create("active"),
+      };
+      expect(compileNode(setDefault)).toBe(
+        'alter column "status" set default $1'
+      );
+
+      const dropDefault: AlterColumnNode = {
+        kind: "AlterColumnNode",
+        column: ColumnNode.create("status"),
+        dropDefault: true,
+      };
+      expect(compileNode(dropDefault)).toBe(
+        'alter column "status" drop default'
+      );
+    });
+  });
+
+  describe("structured ALTER TABLE ADD COLUMN guards", () => {
+    it("rejects adding column with defaultTo", () => {
+      const col = ColumnDefinitionNode.cloneWith(
+        ColumnDefinitionNode.create("score", DataTypeNode.create("integer")),
+        { defaultTo: DefaultValueNode.create(ValueNode.create(0)) }
+      );
+      const node = AddColumnNode.create(col);
+      expect(() => compileNode(node)).toThrow(DSQLQueryCompilerError);
+    });
+
+    it("rejects adding column with notNull", () => {
+      const col = ColumnDefinitionNode.cloneWith(
+        ColumnDefinitionNode.create("score", DataTypeNode.create("integer")),
+        { notNull: true }
+      );
+      const node = AddColumnNode.create(col);
+      expect(() => compileNode(node)).toThrow(DSQLQueryCompilerError);
+    });
+
+    it("rejects adding column with primaryKey", () => {
+      const col = ColumnDefinitionNode.cloneWith(
+        ColumnDefinitionNode.create("score", DataTypeNode.create("integer")),
+        { primaryKey: true }
+      );
+      const node = AddColumnNode.create(col);
+      expect(() => compileNode(node)).toThrow(DSQLQueryCompilerError);
+    });
+
+    it("rejects adding column with unique", () => {
+      const col = ColumnDefinitionNode.cloneWith(
+        ColumnDefinitionNode.create("score", DataTypeNode.create("integer")),
+        { unique: true }
+      );
+      const node = AddColumnNode.create(col);
+      expect(() => compileNode(node)).toThrow(DSQLQueryCompilerError);
+    });
+
+    it("rejects adding column with references", () => {
+      const col = ColumnDefinitionNode.cloneWith(
+        ColumnDefinitionNode.create("user_id", DataTypeNode.create("uuid")),
+        {
+          references: ReferencesNode.create(TableNode.create("users"), [
+            ColumnNode.create("id"),
+          ]),
+        }
+      );
+      const node = AddColumnNode.create(col);
+      expect(() => compileNode(node)).toThrow(DSQLQueryCompilerError);
+    });
+
+    it("rejects adding column with check", () => {
+      const col = ColumnDefinitionNode.cloneWith(
+        ColumnDefinitionNode.create("score", DataTypeNode.create("integer")),
+        {
+          check: CheckConstraintNode.create(
+            RawNode.createWithSql("score >= 0")
+          ),
+        }
+      );
+      const node = AddColumnNode.create(col);
+      expect(() => compileNode(node)).toThrow(DSQLQueryCompilerError);
+    });
+
+    it("rejects adding column with generated", () => {
+      const col = ColumnDefinitionNode.cloneWith(
+        ColumnDefinitionNode.create("score", DataTypeNode.create("integer")),
+        {
+          generated: GeneratedNode.cloneWith(
+            GeneratedNode.createWithExpression(RawNode.createWithSql("1 + 1")),
+            { stored: true }
+          ),
+        }
+      );
+      const node = AddColumnNode.create(col);
+      expect(() => compileNode(node)).toThrow(DSQLQueryCompilerError);
+    });
+
+    it("rejects adding column with autoIncrement or identity", () => {
+      const col1 = ColumnDefinitionNode.cloneWith(
+        ColumnDefinitionNode.create("score", DataTypeNode.create("integer")),
+        { autoIncrement: true }
+      );
+      expect(() => compileNode(AddColumnNode.create(col1))).toThrow(
+        DSQLQueryCompilerError
+      );
+
+      const col2 = ColumnDefinitionNode.cloneWith(
+        ColumnDefinitionNode.create("score", DataTypeNode.create("integer")),
+        { identity: true }
+      );
+      expect(() => compileNode(AddColumnNode.create(col2))).toThrow(
+        DSQLQueryCompilerError
+      );
+    });
+
+    it("rejects adding column with unsigned", () => {
+      const col = ColumnDefinitionNode.cloneWith(
+        ColumnDefinitionNode.create("score", DataTypeNode.create("integer")),
+        { unsigned: true }
+      );
+      const node = AddColumnNode.create(col);
+      expect(() => compileNode(node)).toThrow(DSQLQueryCompilerError);
+    });
+
+    it("compiles plain ADD COLUMN", () => {
+      const col = ColumnDefinitionNode.create(
+        "age",
+        DataTypeNode.create("integer")
+      );
+      const node = AddColumnNode.create(col);
+      expect(compileNode(node)).toBe('add column "age" integer');
+    });
+  });
+
+  describe("structured ALTER TABLE ADD CONSTRAINT guards and NOT VALID emission", () => {
+    it("rejects adding foreign key constraint via ALTER TABLE", () => {
+      const foreignKey = ForeignKeyConstraintNode.create(
+        [ColumnNode.create("user_id")],
+        TableNode.create("users"),
+        [ColumnNode.create("id")]
+      );
+      const node = AddConstraintNode.create(foreignKey);
+      expect(() => compileNode(node)).toThrow(DSQLQueryCompilerError);
+    });
+
+    it("appends NOT VALID when adding check constraint", () => {
+      const checkNode = CheckConstraintNode.create(
+        RawNode.createWithSql("length(name) > 0"),
+        "chk_name"
+      );
+      const node = AddConstraintNode.create(checkNode);
+      expect(compileNode(node)).toBe(
+        'add constraint "chk_name" check (length(name) > 0) not valid'
+      );
+    });
+  });
+
+  describe("structured CREATE INDEX guards and deterministic output", () => {
+    it("rejects index without table", () => {
+      const node: CreateIndexNode = {
+        kind: "CreateIndexNode",
+        name: IdentifierNode.create("idx_test"),
+        columns: [ColumnNode.create("email")],
+      };
+      expect(() => compileNode(node)).toThrow(DSQLQueryCompilerError);
+    });
+
+    it("rejects index without columns", () => {
+      const node: CreateIndexNode = {
+        kind: "CreateIndexNode",
+        name: IdentifierNode.create("idx_test"),
+        table: TableNode.create("users"),
+        columns: [],
+      };
+      expect(() => compileNode(node)).toThrow(DSQLQueryCompilerError);
+    });
+
+    it("rejects index with using clause", () => {
+      const node: CreateIndexNode = {
+        kind: "CreateIndexNode",
+        name: IdentifierNode.create("idx_test"),
+        table: TableNode.create("users"),
+        columns: [ColumnNode.create("email")],
+        using: RawNode.createWithSql("gin"),
+      };
+      expect(() => compileNode(node)).toThrow(DSQLQueryCompilerError);
+    });
+
+    it("rejects index with where clause", () => {
+      // SAFETY: Cast mock where node to WhereNode for test assertion.
+      const mockWhere = {
+        kind: "WhereNode",
+        where: RawNode.createWithSql("active = true"),
+      } as any;
+      const node: CreateIndexNode = {
+        kind: "CreateIndexNode",
+        name: IdentifierNode.create("idx_test"),
+        table: TableNode.create("users"),
+        columns: [ColumnNode.create("email")],
+        where: mockWhere,
+      };
+      expect(() => compileNode(node)).toThrow(DSQLQueryCompilerError);
+    });
+
+    it("rejects index with ordered columns (ASC/DESC)", () => {
+      const orderedCol = OrderByItemNode.create(
+        ColumnNode.create("email"),
+        RawNode.createWithSql("asc")
+      );
+      const node: CreateIndexNode = {
+        kind: "CreateIndexNode",
+        name: IdentifierNode.create("idx_test"),
+        table: TableNode.create("users"),
+        columns: [orderedCol],
+      };
+      expect(() => compileNode(node)).toThrow(DSQLQueryCompilerError);
+    });
+
+    it("rejects index with raw expression columns", () => {
+      const rawCol = RawNode.createWithSql("lower(email)");
+      const node: CreateIndexNode = {
+        kind: "CreateIndexNode",
+        name: IdentifierNode.create("idx_test"),
+        table: TableNode.create("users"),
+        columns: [rawCol],
+      };
+      expect(() => compileNode(node)).toThrow(DSQLQueryCompilerError);
+    });
+
+    it("emits deterministic CREATE INDEX ASYNC", () => {
+      const node: CreateIndexNode = {
+        kind: "CreateIndexNode",
+        name: IdentifierNode.create("idx_users_email"),
+        table: TableNode.create("users"),
+        columns: [ColumnNode.create("email")],
+      };
+      expect(compileNode(node)).toBe(
+        'create index async "idx_users_email" on "users" ("email")'
+      );
+    });
+
+    it("emits deterministic CREATE UNIQUE INDEX ASYNC IF NOT EXISTS", () => {
+      const node: CreateIndexNode = {
+        kind: "CreateIndexNode",
+        name: IdentifierNode.create("idx_users_email"),
+        table: TableNode.create("users"),
+        columns: [ColumnNode.create("email")],
+        unique: true,
+        ifNotExists: true,
+      };
+      expect(compileNode(node)).toBe(
+        'create unique index async if not exists "idx_users_email" on "users" ("email")'
+      );
+    });
+
+    it("emits deterministic index with NULLS NOT DISTINCT", () => {
+      const node: CreateIndexNode = {
+        kind: "CreateIndexNode",
+        name: IdentifierNode.create("idx_users_email"),
+        table: TableNode.create("users"),
+        columns: [ColumnNode.create("email")],
+        nullsNotDistinct: true,
+      };
+      expect(compileNode(node)).toBe(
+        'create index async "idx_users_email" on "users" ("email") nulls not distinct'
+      );
+    });
+  });
+
+  describe("Kysely runtime integration and backstop", () => {
+    it("validates direct sql.raw queries via compiler", async () => {
+      const driver = new SpyDriver();
+      const testDb = createTestDb(driver);
+
+      await expect(
+        sql.raw("TRUNCATE TABLE users;").execute(testDb)
+      ).rejects.toThrow(DSQLQueryCompilerError);
+
+      expect(driver.acquireConnection).not.toHaveBeenCalled();
+    });
+
+    it("validates queries after withoutPlugins()", async () => {
+      const driver = new SpyDriver();
+      const testDb = createTestDb(driver);
+      const bareDb = testDb.withoutPlugins();
+
+      await expect(sql.raw("VACUUM users;").execute(bareDb)).rejects.toThrow(
+        DSQLQueryCompilerError
+      );
+
+      expect(driver.acquireConnection).not.toHaveBeenCalled();
+    });
+
+    it("executes supported queries through driver", async () => {
+      const driver = new SpyDriver();
+      const mockConn: DatabaseConnection = {
+        executeQuery: vi
+          .fn<() => Promise<QueryResult<any>>>()
+          .mockResolvedValue({ rows: [] }),
+        // oxlint-disable-next-line require-yield
+        streamQuery: vi.fn<() => AsyncIterableIterator<QueryResult<any>>>(
+          async function* streamQuery() {}
+        ),
+      };
+      driver.acquireConnection.mockResolvedValue(mockConn);
+      const testDb = createTestDb(driver);
+
+      const result = await testDb.selectFrom("person").selectAll().execute();
+      expect(result).toStrictEqual([]);
+      expect(driver.acquireConnection).toHaveBeenCalledOnce();
+      expect(mockConn.executeQuery).toHaveBeenCalledOnce();
+    });
+  });
+});