create-monolayer-app 0.1.2 → 0.2.1

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

@@ -0,0 +1,518 @@
+import { describe, expect, it } from "vitest";
+
+import type { DSQLValidationCode } from "./query-validation.js";
+import {
+  COMPATIBILITY_RULES,
+  getCompatibilityIssue,
+  validateDSQLStatement,
+} from "./query-validation.js";
+
+const TEST_CASES: readonly {
+  readonly code: DSQLValidationCode;
+  readonly sql: string;
+  readonly expectedFeature: string;
+}[] = [
+  {
+    code: "foreign_key",
+    sql: "CREATE TABLE orders (id uuid PRIMARY KEY, user_id uuid REFERENCES users(id))",
+    expectedFeature: "Foreign key constraints",
+  },
+  {
+    code: "trigger",
+    sql: "CREATE TRIGGER audit_trigger AFTER INSERT ON users FOR EACH ROW EXECUTE PROCEDURE audit_log()",
+    expectedFeature: "Triggers",
+  },
+  {
+    code: "function_language",
+    sql: "CREATE FUNCTION calc_total(qty int, price numeric) RETURNS numeric AS $$ SELECT qty * price $$ LANGUAGE sql",
+    expectedFeature: "User-defined functions",
+  },
+  {
+    code: "procedure",
+    sql: "CREATE PROCEDURE do_something() LANGUAGE plpgsql AS $$ BEGIN NULL; END; $$",
+    expectedFeature: "Stored procedures",
+  },
+  {
+    code: "truncate",
+    sql: "TRUNCATE TABLE audit_events",
+    expectedFeature: "Table truncation",
+  },
+  {
+    code: "listen_notify",
+    sql: "LISTEN cache_invalidation_channel",
+    expectedFeature: "LISTEN and NOTIFY",
+  },
+  {
+    code: "extension",
+    sql: 'CREATE EXTENSION IF NOT EXISTS "uuid-ossp"',
+    expectedFeature: "PostgreSQL extensions",
+  },
+  {
+    code: "postgres_type",
+    sql: "CREATE TYPE order_status AS ENUM ('pending', 'completed')",
+    expectedFeature: "User-defined types and domains",
+  },
+  {
+    code: "temporary_object",
+    sql: "CREATE TEMPORARY TABLE staging_users (id uuid)",
+    expectedFeature: "Temporary and unlogged objects",
+  },
+  {
+    code: "materialized_view",
+    sql: "CREATE MATERIALIZED VIEW user_counts AS SELECT role, count(*) FROM users GROUP BY role",
+    expectedFeature: "Materialized views",
+  },
+  {
+    code: "row_level_security",
+    sql: "ALTER TABLE users ENABLE ROW LEVEL SECURITY",
+    expectedFeature: "Row-level security",
+  },
+  {
+    code: "database_or_tablespace",
+    sql: "CREATE DATABASE tenant_db",
+    expectedFeature: "Database and tablespace management",
+  },
+  {
+    code: "synchronous_index",
+    sql: "CREATE INDEX idx_users_name ON users (name)",
+    expectedFeature: "Synchronous index creation",
+  },
+  {
+    code: "unsupported_index_clause",
+    sql: "CREATE INDEX ASYNC idx_users_name ON users USING btree (name)",
+    expectedFeature: "Unsupported index clauses",
+  },
+  {
+    code: "alter_column_type",
+    sql: "ALTER TABLE users ALTER COLUMN name TYPE varchar(100)",
+    expectedFeature: "Altering column types",
+  },
+  {
+    code: "alter_column_set_not_null",
+    sql: "ALTER TABLE users ALTER COLUMN name SET NOT NULL",
+    expectedFeature: "Setting NOT NULL on existing columns",
+  },
+  {
+    code: "alter_add_column_constraint",
+    sql: "ALTER TABLE users ADD COLUMN score integer DEFAULT 0",
+    expectedFeature: "Adding column constraints during ALTER TABLE",
+  },
+  {
+    code: "create_table_as",
+    sql: "CREATE TABLE users_backup AS SELECT * FROM users",
+    expectedFeature: "CREATE TABLE AS",
+  },
+  {
+    code: "merge",
+    sql: "MERGE INTO target_table USING source_table ON target_table.id = source_table.id WHEN MATCHED THEN UPDATE SET value = source_table.value",
+    expectedFeature: "MERGE statements",
+  },
+  {
+    code: "collation",
+    sql: 'SELECT * FROM users ORDER BY name COLLATE "de_DE"',
+    expectedFeature: "Collations",
+  },
+  {
+    code: "vacuum",
+    sql: "VACUUM FULL users",
+    expectedFeature: "VACUUM and ANALYZE",
+  },
+];
+
+describe(validateDSQLStatement, () => {
+  it("exports compatibility rules in declaration order", () => {
+    expect(COMPATIBILITY_RULES).toHaveLength(TEST_CASES.length);
+    expect(COMPATIBILITY_RULES.map(({ code }) => code)).toStrictEqual(
+      TEST_CASES.map(({ code }) => code)
+    );
+  });
+
+  describe("empty and basic queries", () => {
+    it("accepts empty or whitespace statements", () => {
+      expect(validateDSQLStatement("")).toStrictEqual({ supported: true });
+      expect(validateDSQLStatement("   \n\t  ")).toStrictEqual({
+        supported: true,
+      });
+    });
+
+    it("accepts basic SELECT and INSERT queries", () => {
+      expect(
+        validateDSQLStatement("SELECT id, name FROM users WHERE id = $1")
+      ).toStrictEqual({
+        supported: true,
+      });
+      expect(
+        validateDSQLStatement("INSERT INTO users (id, name) VALUES ($1, $2)")
+      ).toStrictEqual({
+        supported: true,
+      });
+    });
+
+    it("accepts basic UPDATE and DELETE queries", () => {
+      expect(
+        validateDSQLStatement("UPDATE users SET name = $1 WHERE id = $2")
+      ).toStrictEqual({
+        supported: true,
+      });
+      expect(
+        validateDSQLStatement("DELETE FROM users WHERE id = $1")
+      ).toStrictEqual({
+        supported: true,
+      });
+    });
+  });
+
+  describe("supported views and sequences", () => {
+    it("accepts CREATE and DROP VIEW", () => {
+      expect(
+        validateDSQLStatement(
+          "CREATE VIEW active_users AS SELECT id, name FROM users"
+        )
+      ).toStrictEqual({ supported: true });
+      expect(
+        validateDSQLStatement(
+          "CREATE OR REPLACE VIEW active_users AS SELECT id, name FROM users"
+        )
+      ).toStrictEqual({ supported: true });
+      expect(validateDSQLStatement("DROP VIEW active_users")).toStrictEqual({
+        supported: true,
+      });
+    });
+
+    it("accepts CREATE and DROP SEQUENCE", () => {
+      expect(
+        validateDSQLStatement(
+          "CREATE SEQUENCE order_seq START WITH 1 INCREMENT BY 1"
+        )
+      ).toStrictEqual({ supported: true });
+      expect(validateDSQLStatement("DROP SEQUENCE order_seq")).toStrictEqual({
+        supported: true,
+      });
+    });
+
+    it("accepts JSON and JSONB columns", () => {
+      expect(
+        validateDSQLStatement(
+          "CREATE TABLE payload_table (id uuid PRIMARY KEY, config json, data jsonb)"
+        )
+      ).toStrictEqual({ supported: true });
+    });
+  });
+
+  describe("supported ALTER TABLE and INDEX statements", () => {
+    it("accepts DROP and RENAME column and table", () => {
+      expect(
+        validateDSQLStatement("ALTER TABLE users DROP COLUMN old_col")
+      ).toStrictEqual({
+        supported: true,
+      });
+      expect(
+        validateDSQLStatement(
+          "ALTER TABLE users RENAME COLUMN old_name TO new_name"
+        )
+      ).toStrictEqual({ supported: true });
+      expect(
+        validateDSQLStatement("ALTER TABLE users RENAME TO customer_accounts")
+      ).toStrictEqual({
+        supported: true,
+      });
+    });
+
+    it("accepts supported column alterations", () => {
+      expect(
+        validateDSQLStatement("ALTER TABLE users ADD COLUMN age integer")
+      ).toStrictEqual({
+        supported: true,
+      });
+      expect(
+        validateDSQLStatement(
+          "ALTER TABLE users ADD COLUMN IF NOT EXISTS age integer"
+        )
+      ).toStrictEqual({ supported: true });
+      expect(
+        validateDSQLStatement(
+          "ALTER TABLE users ALTER COLUMN status SET DEFAULT 'pending'"
+        )
+      ).toStrictEqual({ supported: true });
+      expect(
+        validateDSQLStatement(
+          "ALTER TABLE users ALTER COLUMN status DROP DEFAULT"
+        )
+      ).toStrictEqual({ supported: true });
+      expect(
+        validateDSQLStatement(
+          "ALTER TABLE users ALTER COLUMN status DROP NOT NULL"
+        )
+      ).toStrictEqual({ supported: true });
+    });
+
+    it("accepts check constraints with NOT VALID", () => {
+      expect(
+        validateDSQLStatement(
+          "ALTER TABLE users ADD CONSTRAINT chk_name CHECK (length(name) > 0) NOT VALID"
+        )
+      ).toStrictEqual({ supported: true });
+      expect(
+        validateDSQLStatement(
+          "ALTER TABLE users ADD CHECK (length(name) > 0) NOT VALID"
+        )
+      ).toStrictEqual({ supported: true });
+    });
+
+    it("accepts supported asynchronous index forms", () => {
+      expect(
+        validateDSQLStatement(
+          "CREATE INDEX ASYNC idx_users_email ON users (email)"
+        )
+      ).toStrictEqual({ supported: true });
+      expect(
+        validateDSQLStatement(
+          "CREATE UNIQUE INDEX ASYNC idx_users_email ON users (email)"
+        )
+      ).toStrictEqual({ supported: true });
+      expect(
+        validateDSQLStatement(
+          "CREATE UNIQUE INDEX ASYNC IF NOT EXISTS idx_users_email ON users (email)"
+        )
+      ).toStrictEqual({ supported: true });
+      expect(
+        validateDSQLStatement(
+          "CREATE INDEX IF NOT EXISTS ASYNC idx_users_email ON users (email)"
+        )
+      ).toStrictEqual({ supported: true });
+      expect(
+        validateDSQLStatement(
+          "CREATE INDEX ASYNC idx_users_email ON users (email) NULLS NOT DISTINCT"
+        )
+      ).toStrictEqual({ supported: true });
+    });
+  });
+
+  describe("false-positive resistance", () => {
+    it("ignores keywords in single-quoted strings", () => {
+      const sql =
+        "SELECT * FROM logs WHERE message = 'FOREIGN KEY REFERENCES VACUUM TRUNCATE'";
+      expect(validateDSQLStatement(sql)).toStrictEqual({ supported: true });
+    });
+
+    it("handles escaped single quotes in strings", () => {
+      const sql =
+        "SELECT * FROM logs WHERE message = 'It''s a FOREIGN KEY REFERENCES test'";
+      expect(validateDSQLStatement(sql)).toStrictEqual({ supported: true });
+    });
+
+    it("ignores keywords in dollar-quoted strings", () => {
+      const sql1 =
+        "INSERT INTO templates (body) VALUES ($$CREATE MATERIALIZED VIEW TEMPORARY TABLE$$)";
+      expect(validateDSQLStatement(sql1)).toStrictEqual({ supported: true });
+
+      const sql2 =
+        "INSERT INTO templates (body) VALUES ($tag$DROP TRIGGER PROCEDURE EXTENSION$tag$)";
+      expect(validateDSQLStatement(sql2)).toStrictEqual({ supported: true });
+    });
+
+    it("ignores keywords in double-quoted identifiers", () => {
+      const sql = 'SELECT "foreign_key", "vacuum", "trigger" FROM "references"';
+      expect(validateDSQLStatement(sql)).toStrictEqual({ supported: true });
+    });
+
+    it("handles escaped double quotes in identifiers", () => {
+      const sql = 'SELECT "my ""foreign_key"" column" FROM "my_table"';
+      expect(validateDSQLStatement(sql)).toStrictEqual({ supported: true });
+    });
+
+    it("ignores keywords in line comments", () => {
+      const sql = `
+        SELECT id FROM users
+        -- Do not use FOREIGN KEY or TRUNCATE TABLE here
+        WHERE id = $1
+      `;
+      expect(validateDSQLStatement(sql)).toStrictEqual({ supported: true });
+    });
+
+    it("ignores keywords in block comments", () => {
+      const sql = `
+        SELECT id FROM users
+        /*
+         * CREATE MATERIALIZED VIEW my_view;
+         * ALTER TABLE users ALTER COLUMN x TYPE int;
+         */
+        WHERE id = $1
+      `;
+      expect(validateDSQLStatement(sql)).toStrictEqual({ supported: true });
+    });
+
+    it("preserves positional parameters", () => {
+      const sql =
+        "SELECT * FROM users WHERE id = $1 AND tenant_id = $2 AND code = $10";
+      expect(validateDSQLStatement(sql)).toStrictEqual({ supported: true });
+    });
+
+    it("handles unclosed string literals and quotes gracefully", () => {
+      expect(
+        validateDSQLStatement(
+          "SELECT * FROM users WHERE note = 'unclosed string"
+        )
+      ).toStrictEqual({
+        supported: true,
+      });
+      expect(
+        validateDSQLStatement('SELECT * FROM "unclosed identifier')
+      ).toStrictEqual({
+        supported: true,
+      });
+      expect(
+        validateDSQLStatement("SELECT * FROM $$unclosed dollar quote")
+      ).toStrictEqual({
+        supported: true,
+      });
+    });
+  });
+
+  describe("unsupported rule detection", () => {
+    it.each(TEST_CASES)("detects $code", ({ code, sql, expectedFeature }) => {
+      const result = validateDSQLStatement(sql);
+      expect(result).toStrictEqual({
+        supported: false,
+        issues: [
+          expect.objectContaining({
+            code,
+            feature: expectedFeature,
+            documentationUrl: expect.stringMatching(
+              /^https:\/\/docs\.aws\.amazon\.com\/aurora-dsql\//u
+            ),
+          }),
+        ],
+      });
+    });
+
+    it("returns multiple matched issues in stable order", () => {
+      const sql = "TRUNCATE TABLE users; VACUUM users;";
+      const result = validateDSQLStatement(sql);
+      expect(result).toStrictEqual({
+        supported: false,
+        issues: [
+          expect.objectContaining({ code: "truncate" }),
+          expect.objectContaining({ code: "vacuum" }),
+        ],
+      });
+    });
+
+    it("detects unsupported index WHERE clause", () => {
+      expect(
+        validateDSQLStatement(
+          "CREATE INDEX ASYNC idx_user_active ON users (email) WHERE active = true"
+        )
+      ).toStrictEqual({
+        supported: false,
+        issues: [
+          expect.objectContaining({
+            code: "unsupported_index_clause",
+          }),
+        ],
+      });
+    });
+
+    it("detects unsupported index ASC clause", () => {
+      expect(
+        validateDSQLStatement(
+          "CREATE INDEX ASYNC idx_user_name ON users (name ASC)"
+        )
+      ).toStrictEqual({
+        supported: false,
+        issues: [
+          expect.objectContaining({
+            code: "unsupported_index_clause",
+          }),
+        ],
+      });
+    });
+
+    it("detects unsupported index NULLS FIRST clause", () => {
+      expect(
+        validateDSQLStatement(
+          "CREATE INDEX ASYNC idx_user_name ON users (name NULLS FIRST)"
+        )
+      ).toStrictEqual({
+        supported: false,
+        issues: [
+          expect.objectContaining({
+            code: "unsupported_index_clause",
+          }),
+        ],
+      });
+    });
+
+    it("detects alter_add_column_constraint with and without COLUMN keyword", () => {
+      expect(
+        validateDSQLStatement(
+          "ALTER TABLE users ADD COLUMN score integer DEFAULT 0"
+        )
+      ).toStrictEqual({
+        supported: false,
+        issues: [
+          expect.objectContaining({
+            code: "alter_add_column_constraint",
+          }),
+        ],
+      });
+
+      expect(
+        validateDSQLStatement("ALTER TABLE users ADD score integer DEFAULT 0")
+      ).toStrictEqual({
+        supported: false,
+        issues: [
+          expect.objectContaining({
+            code: "alter_add_column_constraint",
+          }),
+        ],
+      });
+
+      expect(
+        validateDSQLStatement(
+          "ALTER TABLE users ADD COLUMN is_active boolean NOT NULL"
+        )
+      ).toStrictEqual({
+        supported: false,
+        issues: [
+          expect.objectContaining({
+            code: "alter_add_column_constraint",
+          }),
+        ],
+      });
+    });
+
+    it("detects SELECT INTO as create_table_as", () => {
+      expect(
+        validateDSQLStatement("SELECT * INTO backup_users FROM users")
+      ).toStrictEqual({
+        supported: false,
+        issues: [
+          expect.objectContaining({
+            code: "create_table_as",
+          }),
+        ],
+      });
+    });
+  });
+
+  describe(getCompatibilityIssue, () => {
+    it("returns the issue for a known code", () => {
+      const issue = getCompatibilityIssue("foreign_key");
+      expect(issue.code).toBe("foreign_key");
+      expect(issue.feature).toBe("Foreign key constraints");
+      expect(issue.message).toContain("foreign key");
+      expect(issue.documentationUrl).toContain(
+        "docs.aws.amazon.com/aurora-dsql"
+      );
+    });
+
+    it("throws for an unknown code", () => {
+      // SAFETY: Invalid code is used to test runtime error checking.
+      const invalidCode = "unknown_code" as DSQLValidationCode;
+      expect(() => getCompatibilityIssue(invalidCode)).toThrow(
+        "Unknown compatibility code: unknown_code"
+      );
+    });
+  });
+});

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

@@ -0,0 +1,128 @@
+/**
+ * Aurora DSQL query compatibility validation.
+ *
+ * This module checks SQL statements for known Aurora DSQL restrictions.
+ * It operates on raw SQL strings without throwing errors.
+ */
+
+import { COMPATIBILITY_RULES } from "./compatibility-rules.js";
+import type { CompatibilityRule } from "./compatibility-rules.js";
+
+export { COMPATIBILITY_RULES } from "./compatibility-rules.js";
+
+export type DSQLValidationCode =
+  | "foreign_key"
+  | "trigger"
+  | "function_language"
+  | "procedure"
+  | "truncate"
+  | "listen_notify"
+  | "extension"
+  | "postgres_type"
+  | "temporary_object"
+  | "materialized_view"
+  | "row_level_security"
+  | "database_or_tablespace"
+  | "synchronous_index"
+  | "unsupported_index_clause"
+  | "alter_column_type"
+  | "alter_column_set_not_null"
+  | "alter_add_column_constraint"
+  | "create_table_as"
+  | "merge"
+  | "collation"
+  | "vacuum";
+
+export interface DSQLValidationIssue {
+  readonly code: DSQLValidationCode;
+  readonly feature: string;
+  readonly message: string;
+  readonly documentationUrl: string;
+}
+
+export type DSQLValidationResult =
+  | { readonly supported: true }
+  | {
+      readonly supported: false;
+      readonly issues: readonly DSQLValidationIssue[];
+    };
+
+const SQL_TOKEN_STRIP_REGEX =
+  /--[^\n\r]*|\/\*[\s\S]*?(?:\*\/|$)|'(?:[^']|'')*(?:'|$)|"(?:[^"]|"")*(?:"|$)|(?:\$(?<tag>[A-Za-z_][A-Za-z0-9_]*)?\$[\s\S]*?(?:\$\k<tag>\$|$))/gu;
+
+const stripNonCodeSql = (statement: string): string =>
+  statement.replaceAll(SQL_TOKEN_STRIP_REGEX, " ");
+
+const normalizeSql = (statement: string): string => {
+  const stripped = stripNonCodeSql(statement);
+  return stripped.replaceAll(/\s+/gu, " ").trim().toLowerCase();
+};
+
+const checkRule = (
+  rule: CompatibilityRule,
+  normalizedSql: string
+): DSQLValidationIssue | null => {
+  if (!rule.check(normalizedSql)) {
+    return null;
+  }
+  return {
+    code: rule.code,
+    feature: rule.feature,
+    message: rule.message,
+    documentationUrl: rule.documentationUrl,
+  };
+};
+
+const collectIssues = (
+  normalizedSql: string
+): readonly DSQLValidationIssue[] => {
+  const issues: DSQLValidationIssue[] = [];
+  for (const rule of COMPATIBILITY_RULES) {
+    const issue = checkRule(rule, normalizedSql);
+    if (issue !== null) {
+      issues.push(issue);
+    }
+  }
+  return issues;
+};
+
+/**
+ * Retrieves a predefined validation issue by its error code.
+ *
+ * @param code - The validation code to look up.
+ * @returns The matching DSQLValidationIssue.
+ */
+export function getCompatibilityIssue(
+  code: DSQLValidationCode
+): DSQLValidationIssue {
+  const rule = COMPATIBILITY_RULES.find((r) => r.code === code);
+  if (!rule) {
+    throw new Error(`Unknown compatibility code: ${code}`);
+  }
+  return {
+    code: rule.code,
+    feature: rule.feature,
+    message: rule.message,
+    documentationUrl: rule.documentationUrl,
+  };
+}
+
+/**
+ * Validates a SQL statement against known Amazon Aurora DSQL compatibility rules.
+ *
+ * @param statement - The raw SQL statement string to validate.
+ * @returns A result object indicating whether the statement is supported, with any detected issues.
+ */
+export function validateDSQLStatement(statement: string): DSQLValidationResult {
+  const normalizedSql = normalizeSql(statement);
+  if (normalizedSql.length === 0) {
+    return { supported: true };
+  }
+
+  const issues = collectIssues(normalizedSql);
+  if (issues.length === 0) {
+    return { supported: true };
+  }
+
+  return { supported: false, issues };
+}