create-monolayer-app 0.1.1 → 0.2.0

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

@@ -0,0 +1,259 @@
+import { PostgresQueryCompiler } from "kysely";
+import type {
+  AddColumnNode,
+  AddConstraintNode,
+  AlterColumnNode,
+  AlterTypeNode,
+  ColumnDefinitionNode,
+  CompiledQuery,
+  CreateIndexNode,
+  CreateTableNode,
+  CreateTypeNode,
+  CreateViewNode,
+  DropTypeNode,
+  DropViewNode,
+  ForeignKeyConstraintNode,
+  ModifyColumnNode,
+  OperationNode,
+  QueryId,
+  ReferencesNode,
+  RefreshMaterializedViewNode,
+  RootOperationNode,
+} from "kysely";
+
+import { DSQLQueryCompilerError } from "./query-compiler-error.js";
+import {
+  getCompatibilityIssue,
+  validateDSQLStatement,
+} from "./query-validation.js";
+import type { DSQLValidationCode } from "./query-validation.js";
+
+const throwCompilerIssue = (code: DSQLValidationCode): never => {
+  throw new DSQLQueryCompilerError([getCompatibilityIssue(code)]);
+};
+
+const guardTemporaryTable = (node: CreateTableNode): void => {
+  if (node.temporary || node.onCommit) {
+    throwCompilerIssue("temporary_object");
+  }
+  if (node.selectQuery) {
+    throwCompilerIssue("create_table_as");
+  }
+};
+
+const guardTableConstraints = (node: CreateTableNode): void => {
+  if (node.indexes && node.indexes.length > 0) {
+    throwCompilerIssue("synchronous_index");
+  }
+  if (node.constraints?.some((c) => c.kind === "ForeignKeyConstraintNode")) {
+    throwCompilerIssue("foreign_key");
+  }
+};
+
+const guardColumnDefinition = (node: ColumnDefinitionNode): void => {
+  if (node.references) {
+    throwCompilerIssue("foreign_key");
+  }
+  if (node.autoIncrement || node.identity) {
+    throwCompilerIssue("postgres_type");
+  }
+};
+
+const guardCreateView = (node: CreateViewNode): void => {
+  if (node.temporary) {
+    throwCompilerIssue("temporary_object");
+  }
+  if (node.materialized) {
+    throwCompilerIssue("materialized_view");
+  }
+};
+
+const guardDropView = (node: DropViewNode): void => {
+  if (node.materialized) {
+    throwCompilerIssue("materialized_view");
+  }
+};
+
+const guardAlterColumn = (node: AlterColumnNode): void => {
+  if (node.dataType || node.dataTypeExpression) {
+    throwCompilerIssue("alter_column_type");
+  }
+  if (node.setNotNull) {
+    throwCompilerIssue("alter_column_set_not_null");
+  }
+};
+
+const hasColumnConstraints = (col: ColumnDefinitionNode): boolean =>
+  Boolean(col.defaultTo || col.notNull || col.primaryKey || col.unique);
+
+const hasColumnConstraintModifiers = (col: ColumnDefinitionNode): boolean =>
+  Boolean(col.references || col.check || col.generated);
+
+const hasColumnIdentityModifiers = (col: ColumnDefinitionNode): boolean =>
+  Boolean(col.autoIncrement || col.identity || col.unsigned);
+
+const hasColumnModifiers = (col: ColumnDefinitionNode): boolean =>
+  hasColumnConstraintModifiers(col) || hasColumnIdentityModifiers(col);
+
+const guardAddColumn = (node: AddColumnNode): void => {
+  if (hasColumnConstraints(node.column) || hasColumnModifiers(node.column)) {
+    throwCompilerIssue("alter_add_column_constraint");
+  }
+};
+
+const guardAddConstraint = (node: AddConstraintNode): void => {
+  if (node.constraint.kind === "ForeignKeyConstraintNode") {
+    throwCompilerIssue("foreign_key");
+  }
+};
+
+const hasInvalidIndexColumn = (columns?: readonly OperationNode[]): boolean => {
+  if (!columns || columns.length === 0) {
+    return true;
+  }
+  return columns.some(
+    (col) => col.kind === "OrderByItemNode" || col.kind === "RawNode"
+  );
+};
+
+const guardCreateIndex = (node: CreateIndexNode): void => {
+  if (
+    !node.table ||
+    node.using ||
+    node.where ||
+    hasInvalidIndexColumn(node.columns)
+  ) {
+    throwCompilerIssue("unsupported_index_clause");
+  }
+};
+
+/**
+ * Aurora DSQL query compiler.
+ *
+ * Enforces Aurora DSQL compatibility rules on structured operation nodes
+ * and validates final compiled SQL statements before driver execution.
+ */
+export class DSQLQueryCompiler extends PostgresQueryCompiler {
+  override compileQuery(
+    node: RootOperationNode,
+    queryId: QueryId
+  ): CompiledQuery {
+    const compiled = super.compileQuery(node, queryId);
+    const validation = validateDSQLStatement(compiled.sql);
+    if (!validation.supported) {
+      throw new DSQLQueryCompilerError(validation.issues);
+    }
+    return compiled;
+  }
+
+  protected override visitCreateTable(node: CreateTableNode): void {
+    guardTemporaryTable(node);
+    guardTableConstraints(node);
+    super.visitCreateTable(node);
+  }
+
+  protected override visitColumnDefinition(node: ColumnDefinitionNode): void {
+    guardColumnDefinition(node);
+    super.visitColumnDefinition(node);
+  }
+
+  protected override visitCreateView(node: CreateViewNode): void {
+    guardCreateView(node);
+    super.visitCreateView(node);
+  }
+
+  protected override visitDropView(node: DropViewNode): void {
+    guardDropView(node);
+    super.visitDropView(node);
+  }
+
+  // oxlint-disable-next-line class-methods-use-this
+  protected override visitRefreshMaterializedView(
+    _node: RefreshMaterializedViewNode
+  ): void {
+    throwCompilerIssue("materialized_view");
+  }
+
+  // oxlint-disable-next-line class-methods-use-this
+  protected override visitCreateType(_node: CreateTypeNode): void {
+    throwCompilerIssue("postgres_type");
+  }
+
+  // oxlint-disable-next-line class-methods-use-this
+  protected override visitDropType(_node: DropTypeNode): void {
+    throwCompilerIssue("postgres_type");
+  }
+
+  // oxlint-disable-next-line class-methods-use-this
+  protected override visitAlterType(_node: AlterTypeNode): void {
+    throwCompilerIssue("postgres_type");
+  }
+
+  // oxlint-disable-next-line class-methods-use-this
+  protected override visitForeignKeyConstraint(
+    _node: ForeignKeyConstraintNode
+  ): void {
+    throwCompilerIssue("foreign_key");
+  }
+
+  // oxlint-disable-next-line class-methods-use-this
+  protected override visitReferences(_node: ReferencesNode): void {
+    throwCompilerIssue("foreign_key");
+  }
+
+  // oxlint-disable-next-line class-methods-use-this
+  protected override visitModifyColumn(_node: ModifyColumnNode): void {
+    throwCompilerIssue("alter_column_type");
+  }
+
+  protected override visitAlterColumn(node: AlterColumnNode): void {
+    guardAlterColumn(node);
+    super.visitAlterColumn(node);
+  }
+
+  protected override visitAddColumn(node: AddColumnNode): void {
+    guardAddColumn(node);
+    super.visitAddColumn(node);
+  }
+
+  protected override visitAddConstraint(node: AddConstraintNode): void {
+    guardAddConstraint(node);
+    super.visitAddConstraint(node);
+    if (node.constraint.kind === "CheckConstraintNode") {
+      this.append(" not valid");
+    }
+  }
+
+  private appendIndexPrefix(node: CreateIndexNode): void {
+    this.append("create ");
+    if (node.unique) {
+      this.append("unique ");
+    }
+    this.append("index async ");
+    if (node.ifNotExists) {
+      this.append("if not exists ");
+    }
+    this.visitNode(node.name);
+  }
+
+  private appendIndexTableAndColumns(node: CreateIndexNode): void {
+    if (node.table) {
+      this.append(" on ");
+      this.visitNode(node.table);
+    }
+    if (node.columns) {
+      this.append(" (");
+      this.compileList(node.columns);
+      this.append(")");
+    }
+  }
+
+  protected override visitCreateIndex(node: CreateIndexNode): void {
+    guardCreateIndex(node);
+    this.appendIndexPrefix(node);
+    this.appendIndexTableAndColumns(node);
+    if (node.nullsNotDistinct) {
+      this.append(" nulls not distinct");
+    }
+  }
+}