Add support for Postgres triggers

  - new Trigger type
  - new Trigger element
  - new Trigger interpreter
  - new Trigger validator with validation logic
  - new error codes
  - implements the Postgres exporter
  - tests

Author: scribahti

packages/dbml-core/__tests__/examples/exporter/postgres_exporter/input/trigger.in.dbml

@@ -0,0 +1,37 @@
+Table orders {
+  id int [pk]
+  status varchar
+  amount int
+}
+
+Trigger {
+  name 'trg_orders_before_insert'
+  table orders
+  when before
+  event [insert]
+  for_each row
+  function audit_fn
+}
+
+Trigger {
+  name 'trg_orders_update_check'
+  table orders
+  when after
+  event [insert, update]
+  update_of [status, amount]
+  for_each row
+  condition `NEW.amount > 0`
+  function validate_order
+}
+
+Trigger {
+  name 'trg_fk_check'
+  table orders
+  when after
+  event [insert, update]
+  for_each row
+  function fk_validate_fn
+  constraint true
+  deferrable true
+  timing initially_deferred
+}

packages/dbml-core/__tests__/examples/exporter/postgres_exporter/output/trigger.out.sql

@@ -0,0 +1,25 @@
+CREATE TABLE "orders" (
+  "id" int PRIMARY KEY,
+  "status" varchar,
+  "amount" int
+);
+
+CREATE OR REPLACE TRIGGER trg_orders_before_insert
+  BEFORE INSERT
+  ON "public"."orders"
+  FOR EACH ROW
+  EXECUTE FUNCTION audit_fn();
+
+CREATE OR REPLACE TRIGGER trg_orders_update_check
+  AFTER INSERT OR UPDATE OF status, amount
+  ON "public"."orders"
+  FOR EACH ROW
+  WHEN (NEW.amount > 0)
+  EXECUTE FUNCTION validate_order();
+
+CREATE OR REPLACE CONSTRAINT TRIGGER trg_fk_check
+  AFTER INSERT OR UPDATE
+  ON "public"."orders"
+  DEFERRABLE INITIALLY DEFERRED
+  FOR EACH ROW
+  EXECUTE FUNCTION fk_validate_fn();

packages/dbml-core/src/export/PostgresExporter.js

@@ -574,6 +574,54 @@ class PostgresExporter {
     });
   }
 
+  static exportTriggers (triggerIds, model) {
+    return triggerIds.map((triggerId) => {
+      const trigger = model.triggers[triggerId];
+
+      const isConstraint = trigger.constraint;
+      let line = 'CREATE OR REPLACE ';
+      if (isConstraint) {
+        line += 'CONSTRAINT ';
+      }
+      line += `TRIGGER ${trigger.name}`;
+
+      // WHEN clause (BEFORE/AFTER/INSTEAD OF)
+      const whenClause = trigger.when === 'instead_of' ? 'INSTEAD OF' : trigger.when.toUpperCase();
+
+      // Events
+      const events = trigger.event.map((e) => {
+        if (e === 'update' && trigger.updateOf && trigger.updateOf.length > 0) {
+          return `UPDATE OF ${trigger.updateOf.join(', ')}`;
+        }
+        return e.toUpperCase();
+      });
+      line += `\n  ${whenClause} ${events.join(' OR ')}`;
+
+      // ON table
+      const schemaPrefix = trigger.schemaName ? `"${trigger.schemaName}".` : '';
+      line += `\n  ON ${schemaPrefix}"${trigger.tableName}"`;
+
+      // DEFERRABLE
+      if (trigger.deferrable) {
+        const timingStr = trigger.timing === 'initially_deferred' ? 'INITIALLY DEFERRED' : 'INITIALLY IMMEDIATE';
+        line += `\n  DEFERRABLE ${timingStr}`;
+      }
+
+      // FOR EACH ROW/STATEMENT
+      line += `\n  FOR EACH ${trigger.forEach.toUpperCase()}`;
+
+      // WHEN condition
+      if (trigger.condition) {
+        line += `\n  WHEN (${trigger.condition})`;
+      }
+
+      // EXECUTE FUNCTION
+      line += `\n  EXECUTE FUNCTION ${trigger.functionName}();\n`;
+
+      return line;
+    });
+  }
+
   static export (model) {
     const database = model.database['1'];
 
@@ -665,6 +713,10 @@ class PostgresExporter {
       ? PostgresExporter.exportFunctions(database.functionIds, model)
       : [];
 
+    const triggerStatements = database.triggerIds
+      ? PostgresExporter.exportTriggers(database.triggerIds, model)
+      : [];
+
     const res = concat(
       statements.schemas,
       statements.enums,
@@ -675,6 +727,7 @@ class PostgresExporter {
       recordsSection,
       policyStatements,
       functionStatements,
+      triggerStatements,
     ).join('\n');
     return res;
   }

packages/dbml-core/src/model_structure/database.js

@@ -8,6 +8,7 @@ import StickyNote from './stickyNote';
 import Element from './element';
 import Policy from './policy';
 import Function from './function';
+import Trigger from './trigger';
 import {
   DEFAULT_SCHEMA_NAME, TABLE, TABLE_GROUP, ENUM, REF, NOTE,
 } from './config';
@@ -28,6 +29,7 @@ class Database extends Element {
     tablePartials = [],
     policies = [],
     functions = [],
+    triggers = [],
   }) {
     super();
     this.dbState = new DbState();
@@ -45,6 +47,7 @@ class Database extends Element {
     this.tablePartials = [];
     this.policies = [];
     this.functions = [];
+    this.triggers = [];
 
     // The global array containing references with 1 endpoint being a field injected from a partial to a table
     // These refs are add to this array when resolving partials in tables (`Table.processPartials()`)
@@ -56,6 +59,7 @@ class Database extends Element {
     this.processTablePartials(tablePartials);
     this.processPolicies(policies);
     this.processFunctions(functions);
+    this.processTriggers(triggers);
     this.processSchemas(schemas);
     this.processSchemaElements(enums, ENUM);
     this.processSchemaElements(tables, TABLE);
@@ -113,6 +117,12 @@ class Database extends Element {
     });
   }
 
+  processTriggers (rawTriggers) {
+    rawTriggers.forEach((rawTrigger) => {
+      this.triggers.push(new Trigger({ ...rawTrigger, database: this }));
+    });
+  }
+
   pushNote (note) {
     this.checkNote(note);
     this.notes.push(note);
@@ -255,6 +265,7 @@ class Database extends Element {
       records: this.records.map((r) => ({ ...r })),
       policies: this.policies.map((p) => p.export()),
       functions: this.functions.map((f) => f.export()),
+      triggers: this.triggers.map((t) => t.export()),
     };
   }
 
@@ -264,6 +275,7 @@ class Database extends Element {
       noteIds: this.notes.map((n) => n.id),
       policyIds: this.policies.map((p) => p.id),
       functionIds: this.functions.map((f) => f.id),
+      triggerIds: this.triggers.map((t) => t.id),
     };
   }
 
@@ -292,6 +304,7 @@ class Database extends Element {
       tablePartials: {},
       policies: {},
       functions: {},
+      triggers: {},
     };
 
     this.schemas.forEach((schema) => schema.normalize(normalizedModel));
@@ -300,6 +313,7 @@ class Database extends Element {
     this.tablePartials.forEach((tablePartial) => tablePartial.normalize(normalizedModel));
     this.policies.forEach((policy) => policy.normalize(normalizedModel));
     this.functions.forEach((func) => func.normalize(normalizedModel));
+    this.triggers.forEach((trigger) => trigger.normalize(normalizedModel));
     return normalizedModel;
   }
 }

packages/dbml-core/src/model_structure/dbState.js

@@ -17,6 +17,7 @@ export default class DbState {
     this.tablePartialId = 1;
     this.policyId = 1;
     this.functionId = 1;
+    this.triggerId = 1;
   }
 
   generateId (el) {

packages/dbml-core/src/model_structure/trigger.js

@@ -0,0 +1,61 @@
+import Element from './element';
+
+class Trigger extends Element {
+  constructor ({
+    name, schemaName, tableName, when, event, updateOf, forEach, condition,
+    functionName, constraint, deferrable, timing, token, database = {},
+  } = {}) {
+    super(token);
+    this.name = name;
+    this.schemaName = schemaName;
+    this.tableName = tableName;
+    this.when = when;
+    this.event = event;
+    this.updateOf = updateOf;
+    this.forEach = forEach;
+    this.condition = condition;
+    this.functionName = functionName;
+    this.constraint = constraint;
+    this.deferrable = deferrable;
+    this.timing = timing;
+    this.database = database;
+    this.dbState = this.database.dbState;
+    this.generateId();
+  }
+
+  generateId () {
+    this.id = this.dbState.generateId('triggerId');
+  }
+
+  shallowExport () {
+    return {
+      name: this.name,
+      schemaName: this.schemaName,
+      tableName: this.tableName,
+      when: this.when,
+      event: this.event,
+      updateOf: this.updateOf,
+      forEach: this.forEach,
+      condition: this.condition,
+      functionName: this.functionName,
+      constraint: this.constraint,
+      deferrable: this.deferrable,
+      timing: this.timing,
+    };
+  }
+
+  export () {
+    return {
+      ...this.shallowExport(),
+    };
+  }
+
+  normalize (model) {
+    model.triggers[this.id] = {
+      id: this.id,
+      ...this.shallowExport(),
+    };
+  }
+}
+
+export default Trigger;

packages/dbml-parse/__tests__/snapshots/interpreter/output/array_type.out.json

@@ -153,5 +153,6 @@
   "tablePartials": [],
   "records": [],
   "policies": [],
-  "functions": []
+  "functions": [],
+  "triggers": []
 }

packages/dbml-parse/__tests__/snapshots/interpreter/output/checks.out.json

@@ -364,5 +364,6 @@
   ],
   "records": [],
   "policies": [],
-  "functions": []
+  "functions": [],
+  "triggers": []
 }

packages/dbml-parse/__tests__/snapshots/interpreter/output/column_caller_type.out.json

@@ -148,5 +148,6 @@
   "tablePartials": [],
   "records": [],
   "policies": [],
-  "functions": []
+  "functions": [],
+  "triggers": []
 }

packages/dbml-parse/__tests__/snapshots/interpreter/output/comment.out.json

@@ -404,5 +404,6 @@
   "tablePartials": [],
   "records": [],
   "policies": [],
-  "functions": []
+  "functions": [],
+  "triggers": []
 }