jinaga-server 3.1.5 → 3.3.0

package/integration-test/jinaga-test/package.json

@@ -14,11 +14,11 @@
   "license": "MIT",
   "dependencies": {
     "@stablelib/base64": "^1.0.1",
-    "express": "^4.19.2",
+    "express": "^4.21.1",
     "jest": "^29.7.0",
     "jest-compact-reporter": "^1.2.9",
-    "jinaga": "^6.1.7",
+    "jinaga": "^6.5.0",
     "node-forge": "^1.3.0",
-    "pg": "^8.12.0"
+    "pg": "^8.13.1"
   }
 }

package/integration-test/jinaga-test/purge.test.js

@@ -0,0 +1,224 @@
+const { JinagaServer } = require("./jinaga-server");
+const { createModel, Item, Order, OrderCancelled, OrderCancelledReason, Product, Store } = require("./orderModel");
+
+const host = "db";
+// const host = "localhost";
+const connectionString = `postgresql://dev:devpw@${host}:5432/integrationtest`;
+
+const model = createModel();
+
+describe("After-the-fact purge", () => {
+    let jInit, jPurge;
+    let closeInit, closePurge;
+
+    beforeEach(() => {
+        ({ j: jInit, close: closeInit } = JinagaServer.create({
+            pgKeystore: connectionString,
+            pgStore:    connectionString
+        }));
+
+        ({ j: jPurge, close: closePurge } = JinagaServer.create({
+            pgKeystore: connectionString,
+            pgStore:    connectionString,
+            purgeConditions: p => p
+                .whenExists(model.given(Order).match((order, facts) => facts.ofType(OrderCancelled)
+                    .join(orderCancelled => orderCancelled.order, order)
+                ))
+        }));
+    });
+
+    afterEach(async () => {
+        await closeInit();
+        await closePurge();
+    });
+
+    it("Should find descendants if purge condition is not met", async () => {
+        const store = await jInit.fact(new Store("storeId"));
+        const order = await jInit.fact(new Order(store, new Date()));
+        const item1 = await jInit.fact(new Item(order, new Product(store, "product1"), 1));
+        const item2 = await jInit.fact(new Item(order, new Product(store, "product2"), 1));
+
+        const itemsInOrder = model.given(Order).match(order =>
+            order.successors(Item, item => item.order)
+        );
+
+        await jPurge.purge();
+        const items = await jPurge.query(itemsInOrder, order);
+        expect(items).toEqual([item1, item2]);
+    });
+
+    it("Should purge descendants when condition is met", async () => {
+        const store = await jInit.fact(new Store("storeId"));
+        const order = await jInit.fact(new Order(store, new Date()));
+        const item1 = await jInit.fact(new Item(order, new Product(store, "product1"), 1));
+        const item2 = await jInit.fact(new Item(order, new Product(store, "product2"), 1));
+        const orderCancelled = await jInit.fact(new OrderCancelled(order, new Date()));
+
+        const itemsInOrder = model.given(Order).match(order =>
+            order.successors(Item, item => item.order)
+        );
+
+        await jPurge.purge();
+        const items = await jPurge.query(itemsInOrder, order);
+        expect(items).toEqual([]);
+    });
+
+    it("Should not purge the trigger fact", async () => {
+        const store = await jInit.fact(new Store("storeId"));
+        const order = await jInit.fact(new Order(store, new Date()));
+        const item1 = await jInit.fact(new Item(order, new Product(store, "product1"), 1));
+        const item2 = await jInit.fact(new Item(order, new Product(store, "product2"), 1));
+        const orderCancelled = await jInit.fact(new OrderCancelled(order, new Date()));
+
+        const cancelOfOrder = model.given(Order).match(order =>
+            order.successors(OrderCancelled, cancelled => cancelled.order)
+        );
+
+        await jPurge.purge();
+        const cancels = await jPurge.query(cancelOfOrder, order);
+        expect(cancels).toEqual([orderCancelled]);
+    });
+});
+
+describe("Real-time purge", () => {
+    let j;
+    let close;
+
+    beforeEach(() => {
+        ({ j, close } = JinagaServer.create({
+            pgKeystore: connectionString,
+            pgStore:    connectionString,
+            purgeConditions: p => p
+                .whenExists(model.given(Order).match((order, facts) => facts.ofType(OrderCancelled)
+                    .join(orderCancelled => orderCancelled.order, order)
+                ))
+        }));
+    });
+
+    afterEach(async () => {
+        await close();
+    });
+
+    it("Should find descendants if purge condition is not met", async () => {
+        const store = await j.fact(new Store("storeId"));
+        const order = await j.fact(new Order(store, new Date()));
+        const item1 = await j.fact(new Item(order, new Product(store, "product1"), 1));
+        const item2 = await j.fact(new Item(order, new Product(store, "product2"), 1));
+
+        const itemsInOrder = model.given(Order).match(order =>
+            order.successors(Item, item => item.order)
+        );
+
+        const items = await j.query(itemsInOrder, order);
+        expect(items).toEqual([item1, item2]);
+    });
+
+    it("Should purge descendants when condition is met", async () => {
+        const store = await j.fact(new Store("storeId"));
+        const order = await j.fact(new Order(store, new Date()));
+        const item1 = await j.fact(new Item(order, new Product(store, "product1"), 1));
+        const item2 = await j.fact(new Item(order, new Product(store, "product2"), 1));
+        const orderCancelled = await j.fact(new OrderCancelled(order, new Date()));
+
+        const itemsInOrder = model.given(Order).match(order =>
+            order.successors(Item, item => item.order)
+        );
+
+        const items = await j.query(itemsInOrder, order);
+        expect(items).toEqual([]);
+    });
+
+    it("Should not purge the trigger fact", async () => {
+        const store = await j.fact(new Store("storeId"));
+        const order = await j.fact(new Order(store, new Date()));
+        const item1 = await j.fact(new Item(order, new Product(store, "product1"), 1));
+        const item2 = await j.fact(new Item(order, new Product(store, "product2"), 1));
+        const orderCancelled = await j.fact(new OrderCancelled(order, new Date()));
+
+        const cancelOfOrder = model.given(Order).match(order =>
+            order.successors(OrderCancelled, cancelled => cancelled.order)
+        );
+
+        const cancels = await j.query(cancelOfOrder, order);
+        expect(cancels).toEqual([orderCancelled]);
+    });
+});
+
+describe("After-the-fact purge with deep trigger", () => {
+    let jInit, jPurge;
+    let closeInit, closePurge;
+
+    beforeEach(() => {
+        ({ j: jInit, close: closeInit } = JinagaServer.create({
+            pgKeystore: connectionString,
+            pgStore:    connectionString
+        }));
+
+        ({ j: jPurge, close: closePurge } = JinagaServer.create({
+            pgKeystore: connectionString,
+            pgStore:    connectionString,
+            purgeConditions: p => p
+                .whenExists(model.given(Order).match((order, facts) => facts.ofType(OrderCancelledReason)
+                    .join(orderCancelledReason => orderCancelledReason.orderCancelled.order, order)
+                ))
+        }));
+    });
+
+    afterEach(async () => {
+        await closeInit();
+        await closePurge();
+    });
+
+    it("Should not purge ancestors of the trigger fact", async () => {
+        const store = await jInit.fact(new Store("storeId"));
+        const order = await jInit.fact(new Order(store, new Date()));
+        const item1 = await jInit.fact(new Item(order, new Product(store, "product1"), 1));
+        const item2 = await jInit.fact(new Item(order, new Product(store, "product2"), 1));
+        const orderCancelled = await jInit.fact(new OrderCancelled(order, new Date()));
+        const reason = await jInit.fact(new OrderCancelledReason(orderCancelled, "reason"));
+
+        const cancelOfOrder = model.given(Order).match(order =>
+            order.successors(OrderCancelled, cancelled => cancelled.order)
+        );
+
+        await jPurge.purge();
+        const cancels = await jPurge.query(cancelOfOrder, order);
+        expect(cancels).toEqual([orderCancelled]);
+    });
+});
+
+describe("Real-time purge with deep trigger", () => {
+    let j;
+    let close;
+
+    beforeEach(() => {
+        ({ j, close } = JinagaServer.create({
+            pgKeystore: connectionString,
+            pgStore:    connectionString,
+            purgeConditions: p => p
+                .whenExists(model.given(Order).match((order, facts) => facts.ofType(OrderCancelledReason)
+                    .join(orderCancelledReason => orderCancelledReason.orderCancelled.order, order)
+                ))
+        }));
+    });
+
+    afterEach(async () => {
+        await close();
+    });
+
+    it("Should not purge ancestors of the trigger fact", async () => {
+        const store = await j.fact(new Store("storeId"));
+        const order = await j.fact(new Order(store, new Date()));
+        const item1 = await j.fact(new Item(order, new Product(store, "product1"), 1));
+        const item2 = await j.fact(new Item(order, new Product(store, "product2"), 1));
+        const orderCancelled = await j.fact(new OrderCancelled(order, new Date()));
+        const reason = await j.fact(new OrderCancelledReason(orderCancelled, "reason"));
+
+        const cancelOfOrder = model.given(Order).match(order =>
+            order.successors(OrderCancelled, cancelled => cancelled.order)
+        );
+
+        const cancels = await j.query(cancelOfOrder, order);
+        expect(cancels).toEqual([orderCancelled]);
+    });
+});

package/integration-test/postgres/1-setup.sql

@@ -106,11 +106,13 @@ IF (SELECT to_regclass('public.edge') IS NULL) THEN
         successor_fact_id integer NOT NULL,
         CONSTRAINT fk_successor_fact_id
             FOREIGN KEY (successor_fact_id)
-            REFERENCES fact (fact_id),
+            REFERENCES fact (fact_id)
+            ON DELETE CASCADE,
         predecessor_fact_id integer NOT NULL,
         CONSTRAINT fk_predecessor_fact_id
             FOREIGN KEY (predecessor_fact_id)
             REFERENCES fact (fact_id)
+            ON DELETE CASCADE
     );
 
 
@@ -135,11 +137,13 @@ IF (SELECT to_regclass('public.ancestor') IS NULL) THEN
         fact_id integer NOT NULL,
         CONSTRAINT fk_fact_id
             FOREIGN KEY (fact_id)
-            REFERENCES fact (fact_id),
+            REFERENCES fact (fact_id)
+            ON DELETE CASCADE,
         ancestor_fact_id integer NOT NULL,
         CONSTRAINT fk_ancestor_fact_id
             FOREIGN KEY (ancestor_fact_id)
             REFERENCES fact (fact_id)
+            ON DELETE CASCADE
     );
 
 
@@ -177,7 +181,8 @@ IF (SELECT to_regclass('public.signature') IS NULL) THEN
         fact_id integer NOT NULL,
         CONSTRAINT fk_fact_id
             FOREIGN KEY (fact_id)
-            REFERENCES fact (fact_id),
+            REFERENCES fact (fact_id)
+            ON DELETE CASCADE,
         public_key_id integer NOT NULL,
         CONSTRAINT fk_public_key_id
             FOREIGN KEY (public_key_id)

package/integration-test/postgres/2-grant.sh

@@ -6,12 +6,12 @@ psql -v ON_ERROR_STOP=1 --username "$POSTGRES_USER" --dbname "$APP_DATABASE" <<-
     GRANT SELECT, USAGE ON SEQUENCE fact_type_fact_type_id_seq TO $APP_USERNAME;
     GRANT SELECT,INSERT ON TABLE public.role TO $APP_USERNAME;
     GRANT SELECT, USAGE ON SEQUENCE role_role_id_seq TO $APP_USERNAME;
-    GRANT SELECT,INSERT ON TABLE public.fact TO $APP_USERNAME;
+    GRANT SELECT,INSERT,DELETE ON TABLE public.fact TO $APP_USERNAME;
     GRANT SELECT, USAGE ON SEQUENCE fact_fact_id_seq TO $APP_USERNAME;
-    GRANT SELECT,INSERT ON TABLE public.edge TO $APP_USERNAME;
-    GRANT SELECT,INSERT ON TABLE public.ancestor TO $APP_USERNAME;
+    GRANT SELECT,INSERT,DELETE ON TABLE public.edge TO $APP_USERNAME;
+    GRANT SELECT,INSERT,DELETE ON TABLE public.ancestor TO $APP_USERNAME;
     GRANT SELECT,INSERT ON TABLE public.public_key TO $APP_USERNAME;
     GRANT SELECT, USAGE ON SEQUENCE public_key_public_key_id_seq TO $APP_USERNAME;
-    GRANT SELECT,INSERT ON TABLE public.signature TO $APP_USERNAME;
+    GRANT SELECT,INSERT,DELETE ON TABLE public.signature TO $APP_USERNAME;
     GRANT SELECT,INSERT ON TABLE public.user TO $APP_USERNAME;
 EOSQL

package/integration-test/postgres/Dockerfile

@@ -1,4 +1,4 @@
-FROM postgres:17beta3-bookworm
+FROM postgres:17.1-bookworm
 
 COPY ./0-init-app-db.sh /docker-entrypoint-initdb.d/
 COPY ./1-setup.sql /docker-entrypoint-initdb.d/

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jinaga-server",
-  "version": "3.1.5",
+  "version": "3.3.0",
   "description": "Data management for web and mobile applications.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -10,6 +10,7 @@
     "test": "tsc --noEmit --project tsconfig.test.json && jest",
     "test:watch": "jest --watch",
     "debug": "node ./dist/debug.js",
+    "prepack": "npm run clean && npm run build && npm run test",
     "prepublishOnly": "npm run clean && npm run build && npm run test",
     "integration": "npm run clean && npm run build && cd ./integration-test && ./run.sh",
     "replicator": "npm run build && cd ./replicator && npm run build && npm run start && cd .."
@@ -46,8 +47,8 @@
     "typescript": "^4.7.2"
   },
   "dependencies": {
-    "express": "^4.19.2",
-    "jinaga": "^6.1.7",
-    "pg": "^8.12.0"
+    "express": "^4.21.1",
+    "jinaga": "^6.5.0",
+    "pg": "^8.13.0"
   }
 }