@quatrain/cloudwrapper-supabase 1.1.22 → 1.1.24

package/LICENSE.md

@@ -0,0 +1,15 @@
+# LICENSE UPDATE NOTICE
+
+As of 01/01/2026, Quatrain Core is licensed under the **GNU Affero General Public License v3.0 (AGPL v3)**.
+Previous versions remain under the MIT License.
+
+## Why AGPL?
+
+We believe in open collaboration for the development ecosystem. The AGPL ensures that any modification or deployment of this BaaS stack, including over a network, benefits the entire community.
+
+## Commercial Services & Enterprise Usage
+
+We provide official deployment services, technical training, and certification for Quatrain Core.
+For organizations requiring a non-copyleft license (commercial license) or custom proprietary integrations, please contact the copyright holder: **Quatrain Technologies**.
+
+Copyright © 2024-2026 Quatrain Technologies. All Rights Reserved.

package/README.md

@@ -1,7 +1,10 @@
-# @quatrain/cloudwrapper-supabase
+# Supabase Cloud Wrapper Package
 
-This package provides a Cloud Wrapper adapter for Supabase Edge Functions. It allows you to invoke serverless functions in a consistent way across different BaaS providers.
-This package provides a Cloud Wrapper for Supabase, enabling real-time database and storage triggers. It handles the WebSocket connection to Supabase's Realtime service, providing robust connection monitoring and configurable automatic reconnection logic.
+## Introduction
+
+This package provides a Cloud Wrapper for Supabase, enabling real-time database
+and storage triggers. It handles the WebSocket connection to Supabase's Realtime
+service, providing robust connection monitoring and configurable automatic reconnection logic.
 
 ## Features
 
@@ -16,10 +19,10 @@ This package provides a Cloud Wrapper for Supabase, enabling real-time database
 
 ```bash
 # With npm
-npm install @quatrain/cloudwrapper-supabase @supabase/supabase-js ws
+npm install @quatrain/cloudwrapper-supabase
 
 # With yarn
-yarn add @quatrain/cloudwrapper-supabase @supabase/supabase-js ws
+yarn add @quatrain/cloudwrapper-supabase
 ```
 
 ## Usage
@@ -35,9 +38,9 @@ const wrapper = new SupabaseCloudWrapper({
    url: process.env.SUPABASE_URL,
    key: process.env.SUPABASE_KEY,
    // Optional: Determines behavior on disconnection.
-   // - true (default): Exits the process. Ideal for containerized environments
-   //   (e.g., Kubernetes) that will automatically restart the service.
-   // - false: Attempts to reconnect internally.
+   // - `true` (default): Exits the process. Ideal for containerized
+   //   environments (e.g., Kubernetes) that will automatically restart the service.
+   // - `false`: Attempts to reconnect internally.
    exitOnDisconnect: true,
 })
 
@@ -52,3 +55,16 @@ wrapper.databaseTrigger({
    },
 })
 ```
+
+### Callback Payload
+
+The `script` callback for both `databaseTrigger` and `storageTrigger` receives
+an object with the following properties:
+
+-  `after`: The new state of the record after the event. For `DELETE` events, this will be an empty object.
+-  `before`: The state of the record before the event. For `INSERT` events, this will be an empty object.
+-  `context`: An object containing additional metadata about the event, such as
+   the schema, table, and commit timestamp provided by Supabase's Realtime service.
+
+For `storageTrigger`, the `before` and `after` properties are transformed into a
+`FileType` object, providing a standardized format for file metadata.

package/lib/SupabaseCloudWrapper.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { AbstractCloudWrapper, DatabaseTriggerType, StorageTriggerType } from '@quatrain/cloudwrapper';
-import { SupabaseClient, RealtimeChannel } from '@supabase/supabase-js';
+import { SupabaseClient } from '@supabase/supabase-js';
 import { FileType } from '@quatrain/storage';
 export type SupabaseParams = {
     useEmulator?: boolean;
@@ -8,15 +8,6 @@ export type SupabaseParams = {
     key?: string;
     exitOnDisconnect?: boolean;
 };
-export type Channel = {
-    name: string;
-    channel: RealtimeChannel | undefined;
-    state: any;
-};
-export type Channels = {
-    database: Channel[];
-    storage: Channel[];
-};
 export declare const eventMap: {
     create: string;
     update: string;
@@ -24,11 +15,9 @@ export declare const eventMap: {
 };
 export declare class SupabaseCloudWrapper extends AbstractCloudWrapper {
     protected _supabaseClient: SupabaseClient | undefined;
-    protected _realtimeClient: RealtimeChannel | undefined;
     protected _isInitialized: boolean;
     protected _heartbeatOkReceived: boolean;
     protected _connectionTimeout: NodeJS.Timeout | undefined;
-    protected _channels: Channels;
     constructor(params: SupabaseParams);
     databaseTrigger(trigger: DatabaseTriggerType): void | {
         event: any;

package/lib/SupabaseCloudWrapper.js

@@ -38,17 +38,16 @@ class SupabaseCloudWrapper extends cloudwrapper_1.AbstractCloudWrapper {
         super(params);
         this._isInitialized = false;
         this._heartbeatOkReceived = false;
-        this._channels = { database: [], storage: [] };
         this._initialize();
     }
     databaseTrigger(trigger) {
         var _a;
         this._initialize();
         if (!(this._supabaseClient instanceof supabase_js_1.SupabaseClient)) {
-            throw new Error(`Realtime channel is not enabled`);
+            throw new TypeError(`Supabase client is not enabled`);
         }
         if (typeof trigger.script !== 'function') {
-            throw new Error(`Passed script value is not a function`);
+            throw new TypeError(`Passed script value is not a function`);
         }
         if (Array.isArray(trigger.event)) {
             const params = trigger.event.forEach((event) => {
@@ -64,7 +63,7 @@ class SupabaseCloudWrapper extends cloudwrapper_1.AbstractCloudWrapper {
                 table: trigger.model,
             };
             cloudwrapper_1.CloudWrapper.info(`Set up DB trigger ${trigger.name} for ${trigger.event} event on table ${schema}.${params.table}`);
-            const channel = (_a = this._supabaseClient) === null || _a === void 0 ? void 0 : _a.channel(trigger.name).on('postgres_changes', params, (_b) => __awaiter(this, void 0, void 0, function* () {
+            (_a = this._supabaseClient) === null || _a === void 0 ? void 0 : _a.channel(trigger.name).on('postgres_changes', params, (_b) => __awaiter(this, void 0, void 0, function* () {
                 var { old: before, new: after } = _b, context = __rest(_b, ["old", "new"]);
                 cloudwrapper_1.CloudWrapper.info(`Triggering function on event ${trigger.name}`);
                 try {
@@ -75,11 +74,6 @@ class SupabaseCloudWrapper extends cloudwrapper_1.AbstractCloudWrapper {
                     console.log(err);
                 }
             })).subscribe();
-            this._channels.database.push({
-                name: trigger.name,
-                channel,
-                state: channel.state,
-            });
             return params;
         }
         catch (err) {
@@ -106,7 +100,7 @@ class SupabaseCloudWrapper extends cloudwrapper_1.AbstractCloudWrapper {
                 table: 'objects',
             };
             cloudwrapper_1.CloudWrapper.info(`Set up Storage trigger ${trigger.name} for ${trigger.event} event`);
-            const channel = (_a = this._supabaseClient) === null || _a === void 0 ? void 0 : _a.channel(trigger.name).on('postgres_changes', params, (_b) => __awaiter(this, void 0, void 0, function* () {
+            (_a = this._supabaseClient) === null || _a === void 0 ? void 0 : _a.channel(trigger.name).on('postgres_changes', params, (_b) => __awaiter(this, void 0, void 0, function* () {
                 var { old: before, new: after } = _b, context = __rest(_b, ["old", "new"]);
                 cloudwrapper_1.CloudWrapper.info(`Triggering storage function on event ${trigger.name}`);
                 try {
@@ -122,11 +116,6 @@ class SupabaseCloudWrapper extends cloudwrapper_1.AbstractCloudWrapper {
                     cloudwrapper_1.CloudWrapper.error(err.message);
                 }
             })).subscribe();
-            this._channels.storage.push({
-                name: trigger.name,
-                channel,
-                state: channel === null || channel === void 0 ? void 0 : channel.state,
-            });
             return params;
         }
         catch (err) {
@@ -156,19 +145,18 @@ class SupabaseCloudWrapper extends cloudwrapper_1.AbstractCloudWrapper {
                                 }
                                 break;
                             case 'timeout':
-                                cloudwrapper_1.CloudWrapper.warn(`⚠️ Supabase Realtime connection timed out`);
-                                break;
+                            case 'error':
                             case 'disconnected':
                                 // Reconnect only if exitOnDisconnect is explicitly set to false.
                                 if (this._params.exitOnDisconnect === false) {
-                                    cloudwrapper_1.CloudWrapper.warn(`❌ Supabase connection lost. Attempting to reconnect...`);
+                                    cloudwrapper_1.CloudWrapper.warn(`❌ Supabase connection lost (status: ${status}). Attempting to reconnect...`);
                                     this._isInitialized = false;
                                     this._heartbeatOkReceived = false;
                                     this._initialize();
                                 }
                                 else {
                                     // Default behavior: exit to allow for a clean restart by the orchestrator.
-                                    cloudwrapper_1.CloudWrapper.error(`❌ Supabase connection lost. Exiting to allow for a clean restart.`);
+                                    cloudwrapper_1.CloudWrapper.error(`❌ Supabase connection lost (status: ${status}). Exiting to allow for a clean restart.`);
                                     process.exit(1);
                                 }
                                 break;

package/lib/SupabaseCloudWrapper.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/SupabaseCloudWrapper.test.js

@@ -0,0 +1,393 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const SupabaseCloudWrapper_1 = require("./SupabaseCloudWrapper");
+const backend_1 = require("@quatrain/backend");
+const supabase_js_1 = require("@supabase/supabase-js");
+// Mock dependencies
+jest.mock('@supabase/supabase-js');
+jest.mock('ws');
+describe('SupabaseCloudWrapper', () => {
+    let wrapper;
+    let mockChannel;
+    let mockSubscribe;
+    let mockOn;
+    let mockSupabaseClient;
+    let processExitSpy;
+    let heartbeatCallback;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.clearAllTimers();
+        jest.useFakeTimers();
+        // Spy on process.exit to prevent actual exits
+        processExitSpy = jest.spyOn(process, 'exit').mockImplementation(() => {
+            throw new Error('process.exit called');
+        });
+        // Create mock subscription chain
+        mockSubscribe = jest.fn().mockReturnValue(undefined);
+        mockOn = jest.fn().mockReturnValue({ subscribe: mockSubscribe });
+        mockChannel = jest.fn().mockReturnValue({ on: mockOn });
+        // Create mock Supabase client
+        mockSupabaseClient = {
+            channel: mockChannel,
+        };
+        supabase_js_1.createClient.mockImplementation((url, key, options) => {
+            var _a;
+            heartbeatCallback = (_a = options === null || options === void 0 ? void 0 : options.realtime) === null || _a === void 0 ? void 0 : _a.heartbeatCallback;
+            const client = new supabase_js_1.SupabaseClient(url, key, options);
+            Object.assign(client, { channel: mockChannel });
+            return client;
+        });
+    });
+    afterEach(() => {
+        jest.useRealTimers();
+        processExitSpy.mockRestore();
+    });
+    describe('eventMap', () => {
+        it('should map BackendAction to Supabase events', () => {
+            expect(SupabaseCloudWrapper_1.eventMap[backend_1.BackendAction.CREATE]).toBe('INSERT');
+            expect(SupabaseCloudWrapper_1.eventMap[backend_1.BackendAction.UPDATE]).toBe('UPDATE');
+            expect(SupabaseCloudWrapper_1.eventMap[backend_1.BackendAction.DELETE]).toBe('DELETE');
+        });
+    });
+    describe('Constructor and Initialization', () => {
+        it('should create Supabase client with correct params', () => {
+            wrapper = new SupabaseCloudWrapper_1.SupabaseCloudWrapper({
+                url: 'https://test.supabase.co',
+                key: 'test-key-123',
+            });
+            expect(supabase_js_1.createClient).toHaveBeenCalledWith('https://test.supabase.co', 'test-key-123', expect.objectContaining({
+                realtime: expect.objectContaining({
+                    transport: expect.anything(),
+                    heartbeatIntervalMs: 5000,
+                    heartbeatCallback: expect.any(Function),
+                }),
+            }));
+        });
+        it('should set initialization flag', () => {
+            wrapper = new SupabaseCloudWrapper_1.SupabaseCloudWrapper({
+                url: 'https://test.supabase.co',
+                key: 'test-key',
+            });
+            expect(wrapper._isInitialized).toBe(true);
+        });
+        it('should initialize heartbeat monitoring', () => {
+            wrapper = new SupabaseCloudWrapper_1.SupabaseCloudWrapper({
+                url: 'https://test.supabase.co',
+                key: 'test-key',
+            });
+            expect(heartbeatCallback).toBeDefined();
+            expect(typeof heartbeatCallback).toBe('function');
+        });
+        it('should set connection timeout', () => {
+            wrapper = new SupabaseCloudWrapper_1.SupabaseCloudWrapper({
+                url: 'https://test.supabase.co',
+                key: 'test-key',
+            });
+            expect(wrapper._connectionTimeout).toBeDefined();
+        });
+    });
+    describe('Heartbeat Monitoring', () => {
+        beforeEach(() => {
+            wrapper = new SupabaseCloudWrapper_1.SupabaseCloudWrapper({
+                url: 'https://test.supabase.co',
+                key: 'test-key',
+            });
+        });
+        it('should handle "ok" heartbeat status', () => {
+            expect(wrapper._heartbeatOkReceived).toBe(false);
+            heartbeatCallback('ok');
+            expect(wrapper._heartbeatOkReceived).toBe(true);
+        });
+        it('should clear timeout on successful heartbeat', () => {
+            const initialTimeout = wrapper._connectionTimeout;
+            heartbeatCallback('ok');
+            expect(wrapper._connectionTimeout).toBe(initialTimeout);
+        });
+        it('should handle "timeout" status', () => {
+            // Should not throw or exit
+            expect(() => heartbeatCallback('timeout')).not.toThrow();
+        });
+        it('should reconnect on "disconnected" when exitOnDisconnect is false', () => {
+            wrapper = new SupabaseCloudWrapper_1.SupabaseCloudWrapper({
+                url: 'https://test.supabase.co',
+                key: 'test-key',
+                exitOnDisconnect: false,
+            });
+            const createClientCallsBefore = supabase_js_1.createClient.mock.calls
+                .length;
+            heartbeatCallback = supabase_js_1.createClient.mock.calls[createClientCallsBefore - 1][2].realtime.heartbeatCallback;
+            heartbeatCallback('disconnected');
+            // Should attempt reconnection (call createClient again)
+            expect(supabase_js_1.createClient.mock.calls.length).toBeGreaterThan(createClientCallsBefore);
+        });
+        it('should exit on "disconnected" by default', () => {
+            expect(() => heartbeatCallback('disconnected')).toThrow('process.exit called');
+            expect(processExitSpy).toHaveBeenCalledWith(1);
+        });
+        it('should exit on "disconnected" when exitOnDisconnect is true', () => {
+            wrapper = new SupabaseCloudWrapper_1.SupabaseCloudWrapper({
+                url: 'https://test.supabase.co',
+                key: 'test-key',
+                exitOnDisconnect: true,
+            });
+            heartbeatCallback = supabase_js_1.createClient.mock.calls[1][2]
+                .realtime.heartbeatCallback;
+            expect(() => heartbeatCallback('disconnected')).toThrow('process.exit called');
+            expect(processExitSpy).toHaveBeenCalledWith(1);
+        });
+    });
+    describe('Connection Timeout', () => {
+        it('should exit if heartbeat not received within 30 seconds', () => {
+            wrapper = new SupabaseCloudWrapper_1.SupabaseCloudWrapper({
+                url: 'https://test.supabase.co',
+                key: 'test-key',
+            });
+            expect(() => jest.advanceTimersByTime(30000)).toThrow('process.exit called');
+            expect(processExitSpy).toHaveBeenCalledWith(1);
+        });
+        it('should not exit if heartbeat received before timeout', () => {
+            wrapper = new SupabaseCloudWrapper_1.SupabaseCloudWrapper({
+                url: 'https://test.supabase.co',
+                key: 'test-key',
+            });
+            heartbeatCallback('ok');
+            expect(() => jest.advanceTimersByTime(30000)).not.toThrow();
+            expect(processExitSpy).not.toHaveBeenCalled();
+        });
+    });
+    describe('databaseTrigger()', () => {
+        beforeEach(() => {
+            wrapper = new SupabaseCloudWrapper_1.SupabaseCloudWrapper({
+                url: 'https://test.supabase.co',
+                key: 'test-key',
+            });
+            heartbeatCallback('ok'); // Simulate successful connection
+        });
+        it('should set up single event trigger', () => {
+            const trigger = {
+                name: 'test-trigger',
+                event: backend_1.BackendAction.CREATE,
+                script: jest.fn(),
+                model: 'users',
+                path: '/users/{id}',
+                schema: 'public',
+            };
+            wrapper.databaseTrigger(trigger);
+            expect(mockChannel).toHaveBeenCalledWith('test-trigger');
+            expect(mockOn).toHaveBeenCalledWith('postgres_changes', {
+                event: 'INSERT',
+                schema: 'public',
+                table: 'users',
+            }, expect.any(Function));
+            expect(mockSubscribe).toHaveBeenCalled();
+        });
+        it('should use default schema if not provided', () => {
+            const trigger = {
+                name: 'test-trigger',
+                event: backend_1.BackendAction.UPDATE,
+                script: jest.fn(),
+                model: 'posts',
+                path: '/posts/{id}',
+            };
+            wrapper.databaseTrigger(trigger);
+            expect(mockOn).toHaveBeenCalledWith('postgres_changes', expect.objectContaining({
+                schema: 'public',
+            }), expect.any(Function));
+        });
+        it('should handle multiple events', () => {
+            const trigger = {
+                name: 'multi-trigger',
+                event: [backend_1.BackendAction.CREATE, backend_1.BackendAction.UPDATE],
+                script: jest.fn(),
+                model: 'comments',
+                path: '/comments/{id}',
+            };
+            wrapper.databaseTrigger(trigger);
+            expect(mockChannel).toHaveBeenCalledWith('multi-trigger-create');
+            expect(mockChannel).toHaveBeenCalledWith('multi-trigger-update');
+            expect(mockSubscribe).toHaveBeenCalledTimes(2);
+        });
+        it('should throw TypeError if script is not a function', () => {
+            const trigger = {
+                name: 'bad-trigger',
+                event: backend_1.BackendAction.CREATE,
+                script: 'not-a-function',
+                model: 'users',
+                path: '/users/{id}',
+            };
+            expect(() => wrapper.databaseTrigger(trigger)).toThrow(TypeError);
+            expect(() => wrapper.databaseTrigger(trigger)).toThrow('Passed script value is not a function');
+        });
+        it('should execute script with payload when event fires', () => __awaiter(void 0, void 0, void 0, function* () {
+            const scriptMock = jest.fn().mockResolvedValue(undefined);
+            const trigger = {
+                name: 'test-trigger',
+                event: backend_1.BackendAction.CREATE,
+                script: scriptMock,
+                model: 'users',
+                path: '/users/{id}',
+            };
+            wrapper.databaseTrigger(trigger);
+            // Get the callback passed to .on()
+            const callback = mockOn.mock.calls[0][2];
+            const payload = {
+                old: { id: 1, name: 'old' },
+                new: { id: 1, name: 'new' },
+                extra: 'context',
+            };
+            yield callback(payload);
+            expect(scriptMock).toHaveBeenCalledWith({
+                before: payload.old,
+                after: payload.new,
+                context: { extra: 'context' },
+            });
+        }));
+    });
+    describe('storageTrigger()', () => {
+        beforeEach(() => {
+            wrapper = new SupabaseCloudWrapper_1.SupabaseCloudWrapper({
+                url: 'https://test.supabase.co',
+                key: 'test-key',
+            });
+            heartbeatCallback('ok');
+        });
+        it('should set up single event storage trigger', () => {
+            const trigger = {
+                name: 'storage-trigger',
+                event: backend_1.BackendAction.CREATE,
+                script: jest.fn(),
+            };
+            wrapper.storageTrigger(trigger);
+            expect(mockChannel).toHaveBeenCalledWith('storage-trigger');
+            expect(mockOn).toHaveBeenCalledWith('postgres_changes', {
+                event: 'INSERT',
+                schema: 'storage',
+                table: 'objects',
+            }, expect.any(Function));
+            expect(mockSubscribe).toHaveBeenCalled();
+        });
+        it('should handle multiple events', () => {
+            const trigger = {
+                name: 'multi-storage',
+                event: [backend_1.BackendAction.CREATE, backend_1.BackendAction.DELETE],
+                script: jest.fn(),
+            };
+            wrapper.storageTrigger(trigger);
+            expect(mockChannel).toHaveBeenCalledWith('multi-storage-create');
+            expect(mockChannel).toHaveBeenCalledWith('multi-storage-delete');
+            expect(mockSubscribe).toHaveBeenCalledTimes(2);
+        });
+        it('should throw TypeError if script is not a function', () => {
+            const trigger = {
+                name: 'bad-storage',
+                event: backend_1.BackendAction.CREATE,
+                script: 123,
+            };
+            expect(() => wrapper.storageTrigger(trigger)).toThrow(TypeError);
+        });
+        it('should transform payload and execute script', () => __awaiter(void 0, void 0, void 0, function* () {
+            const scriptMock = jest.fn().mockResolvedValue(undefined);
+            const trigger = {
+                name: 'storage-trigger',
+                event: backend_1.BackendAction.CREATE,
+                script: scriptMock,
+            };
+            wrapper.storageTrigger(trigger);
+            const callback = mockOn.mock.calls[0][2];
+            const payload = {
+                old: {},
+                new: {
+                    bucket_id: 'uploads',
+                    name: 'test.jpg',
+                    metadata: { size: 1024, mimetype: 'image/jpeg' },
+                },
+                context: 'test-context',
+            };
+            yield callback(payload);
+            expect(scriptMock).toHaveBeenCalledWith({
+                before: undefined,
+                after: {
+                    host: 'supabase',
+                    bucket: 'uploads',
+                    ref: 'test.jpg',
+                    contentType: 'image/jpeg',
+                    size: 1024,
+                },
+                context: { context: 'test-context' },
+            });
+        }));
+    });
+    describe('_payload2File()', () => {
+        beforeEach(() => {
+            wrapper = new SupabaseCloudWrapper_1.SupabaseCloudWrapper({
+                url: 'https://test.supabase.co',
+                key: 'test-key',
+            });
+        });
+        it('should convert valid payload to FileType', () => {
+            const payload = {
+                bucket_id: 'avatars',
+                name: 'profile.png',
+                metadata: {
+                    size: 2048,
+                    mimetype: 'image/png',
+                },
+            };
+            const result = wrapper._payload2File(payload);
+            expect(result).toEqual({
+                host: 'supabase',
+                bucket: 'avatars',
+                ref: 'profile.png',
+                contentType: 'image/png',
+                size: 2048,
+            });
+        });
+        it('should return undefined for payload without metadata', () => {
+            const payload = {
+                bucket_id: 'uploads',
+                name: 'file.txt',
+            };
+            const result = wrapper._payload2File(payload);
+            expect(result).toBeUndefined();
+        });
+        it('should return undefined for empty payload', () => {
+            const payload = {};
+            const result = wrapper._payload2File(payload);
+            expect(result).toBeUndefined();
+        });
+        it('should handle missing size or mimetype', () => {
+            const payload = {
+                bucket_id: 'docs',
+                name: 'document.pdf',
+                metadata: {},
+            };
+            const result = wrapper._payload2File(payload);
+            expect(result).toEqual({
+                host: 'supabase',
+                bucket: 'docs',
+                ref: 'document.pdf',
+                contentType: undefined,
+                size: undefined,
+            });
+        });
+    });
+    describe('Module Exports', () => {
+        it('should export SupabaseCloudWrapper', () => {
+            expect(SupabaseCloudWrapper_1.SupabaseCloudWrapper).toBeDefined();
+            expect(typeof SupabaseCloudWrapper_1.SupabaseCloudWrapper).toBe('function');
+        });
+        it('should export eventMap', () => {
+            expect(SupabaseCloudWrapper_1.eventMap).toBeDefined();
+            expect(typeof SupabaseCloudWrapper_1.eventMap).toBe('object');
+        });
+    });
+});

package/package.json

@@ -1,52 +1,51 @@
 {
-  "name": "@quatrain/cloudwrapper-supabase",
-  "version": "1.1.22",
-  "license": "MIT",
-  "description": "Cloud Wrapper adapter for Supabase",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/quatrain/Core.git",
-    "directory": "packages/cloudwrapper-supabase"
-  },
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
-  "files": [
-    "src/",
-    "lib/",
-    "README.md"
-  ],
-  "author": "Quatrain Développement SAS <developers@quatrain.com>",
-  "peerDependencies": {
-    "@quatrain/core": "^1.1.22"
-  },
-  "dependencies": {
-    "@quatrain/backend": "^1.1.22",
-    "@quatrain/cloudwrapper": "^1.1.14",
-    "@supabase/supabase-js": "^2.82.0",
-    "ws": "^8.18.3"
-  },
-  "devDependencies": {
-    "@tsconfig/recommended": "^1.0.1",
-    "@types/jest": "^27.0.3",
-    "@types/node": "^22.10.1",
-    "@types/ws": "^8.18.1",
-    "jest": "^30.1.2",
-    "jest-node-exports-resolver": "^1.1.6",
-    "jest-serial-runner": "^1.2.2",
-    "trace-unhandled": "^2.0.1",
-    "ts-jest": "^27.1.2",
-    "ts-node": "^10.9.1",
-    "typescript": "^5.1.5"
-  },
-  "scripts": {
-    "test-ci": "jest --runInBand",
-    "build": "tsc",
-    "wbuild": "tsc --watch",
-    "bump-to": "yarn version",
-    "hash": "node ../../bin/hashFolder.js",
-    "hash:persist": "yarn hash  > .hash_latest.txt",
-    "hash:compare": "yarn hash > .hash_newest.txt && cmp -s .hash_latest.txt .hash_newest.txt",
-    "publish": "yarn hash:compare || yarn publish:process",
-    "publish:process": "yarn version patch && yarn build && yarn npm publish --access public && yarn hash:persist"
-  }
-}
+   "name": "@quatrain/cloudwrapper-supabase",
+   "version": "1.1.24",
+   "license": "AGPL-3.0-only",
+   "description": "Cloud Wrapper adapter for Supabase",
+   "repository": {
+      "type": "git",
+      "url": "https://github.com/quatrain/Core.git",
+      "directory": "packages/cloudwrapper-supabase"
+   },
+   "main": "lib/index.js",
+   "types": "lib/index.d.ts",
+   "bun": "src/index.ts",
+   "files": [
+      "LICENSE.md",
+      "src/",
+      "lib/",
+      "README.md"
+   ],
+   "author": "Quatrain Développement SAS <developers@quatrain.com>",
+   "peerDependencies": {
+      "@quatrain/core": "^1.1.42"
+   },
+   "dependencies": {
+      "@quatrain/backend": "^1.1.26",
+      "@quatrain/cloudwrapper": "^1.1.15",
+      "@quatrain/core": "^1.1.42",
+      "@quatrain/storage": "^1.1.23",
+      "@supabase/supabase-js": "^2.87.3",
+      "ws": "^8.18.3"
+   },
+   "devDependencies": {
+      "@tsconfig/recommended": "^1.0.1",
+      "@types/jest": "^30.0.0",
+      "@types/node": "^22.10.1",
+      "@types/ws": "^8.18.1",
+      "jest": "^30.2.0",
+      "jest-node-exports-resolver": "^1.1.6",
+      "jest-serial-runner": "^1.2.2",
+      "trace-unhandled": "^2.0.1",
+      "ts-jest": "^29.4.1",
+      "ts-node": "^10.9.1",
+      "typescript": "^5.2.2"
+   },
+   "scripts": {
+      "test-ci": "jest --runInBand",
+      "build": "tsc",
+      "wbuild": "tsc --watch",
+      "bump-to": "yarn version"
+   }
+}

package/src/SupabaseCloudWrapper.test.ts

@@ -0,0 +1,498 @@
+import { SupabaseCloudWrapper, eventMap } from './SupabaseCloudWrapper'
+import { BackendAction } from '@quatrain/backend'
+import { DatabaseTriggerType, StorageTriggerType } from '@quatrain/cloudwrapper'
+import { createClient, SupabaseClient } from '@supabase/supabase-js'
+
+// Mock dependencies
+jest.mock('@supabase/supabase-js')
+jest.mock('ws')
+
+describe('SupabaseCloudWrapper', () => {
+   let wrapper: SupabaseCloudWrapper
+   let mockChannel: any
+   let mockSubscribe: jest.Mock
+   let mockOn: jest.Mock
+   let mockSupabaseClient: any
+   let processExitSpy: jest.SpyInstance
+   let heartbeatCallback: any
+
+   beforeEach(() => {
+      jest.clearAllMocks()
+      jest.clearAllTimers()
+      jest.useFakeTimers()
+
+      // Spy on process.exit to prevent actual exits
+      processExitSpy = jest.spyOn(process, 'exit').mockImplementation(() => {
+         throw new Error('process.exit called')
+      })
+
+      // Create mock subscription chain
+      mockSubscribe = jest.fn().mockReturnValue(undefined)
+      mockOn = jest.fn().mockReturnValue({ subscribe: mockSubscribe })
+      mockChannel = jest.fn().mockReturnValue({ on: mockOn })
+
+      // Create mock Supabase client
+      mockSupabaseClient = {
+         channel: mockChannel,
+      }
+
+      // Mock createClient to capture heartbeat callback
+      ;(createClient as jest.Mock).mockImplementation((url, key, options) => {
+         heartbeatCallback = options?.realtime?.heartbeatCallback
+         const client = new SupabaseClient(url, key, options)
+         Object.assign(client, { channel: mockChannel })
+         return client
+      })
+   })
+
+   afterEach(() => {
+      jest.useRealTimers()
+      processExitSpy.mockRestore()
+   })
+
+   describe('eventMap', () => {
+      it('should map BackendAction to Supabase events', () => {
+         expect(eventMap[BackendAction.CREATE]).toBe('INSERT')
+         expect(eventMap[BackendAction.UPDATE]).toBe('UPDATE')
+         expect(eventMap[BackendAction.DELETE]).toBe('DELETE')
+      })
+   })
+
+   describe('Constructor and Initialization', () => {
+      it('should create Supabase client with correct params', () => {
+         wrapper = new SupabaseCloudWrapper({
+            url: 'https://test.supabase.co',
+            key: 'test-key-123',
+         })
+
+         expect(createClient).toHaveBeenCalledWith(
+            'https://test.supabase.co',
+            'test-key-123',
+            expect.objectContaining({
+               realtime: expect.objectContaining({
+                  transport: expect.anything(),
+                  heartbeatIntervalMs: 5000,
+                  heartbeatCallback: expect.any(Function),
+               }),
+            })
+         )
+      })
+
+      it('should set initialization flag', () => {
+         wrapper = new SupabaseCloudWrapper({
+            url: 'https://test.supabase.co',
+            key: 'test-key',
+         })
+
+         expect((wrapper as any)._isInitialized).toBe(true)
+      })
+
+      it('should initialize heartbeat monitoring', () => {
+         wrapper = new SupabaseCloudWrapper({
+            url: 'https://test.supabase.co',
+            key: 'test-key',
+         })
+
+         expect(heartbeatCallback).toBeDefined()
+         expect(typeof heartbeatCallback).toBe('function')
+      })
+
+      it('should set connection timeout', () => {
+         wrapper = new SupabaseCloudWrapper({
+            url: 'https://test.supabase.co',
+            key: 'test-key',
+         })
+
+         expect((wrapper as any)._connectionTimeout).toBeDefined()
+      })
+   })
+
+   describe('Heartbeat Monitoring', () => {
+      beforeEach(() => {
+         wrapper = new SupabaseCloudWrapper({
+            url: 'https://test.supabase.co',
+            key: 'test-key',
+         })
+      })
+
+      it('should handle "ok" heartbeat status', () => {
+         expect((wrapper as any)._heartbeatOkReceived).toBe(false)
+
+         heartbeatCallback('ok')
+
+         expect((wrapper as any)._heartbeatOkReceived).toBe(true)
+      })
+
+      it('should clear timeout on successful heartbeat', () => {
+         const initialTimeout = (wrapper as any)._connectionTimeout
+
+         heartbeatCallback('ok')
+
+         expect((wrapper as any)._connectionTimeout).toBe(initialTimeout)
+      })
+
+      it('should handle "timeout" status', () => {
+         // Should not throw or exit
+         expect(() => heartbeatCallback('timeout')).not.toThrow()
+      })
+
+      it('should reconnect on "disconnected" when exitOnDisconnect is false', () => {
+         wrapper = new SupabaseCloudWrapper({
+            url: 'https://test.supabase.co',
+            key: 'test-key',
+            exitOnDisconnect: false,
+         })
+
+         const createClientCallsBefore = (createClient as jest.Mock).mock.calls
+            .length
+
+         heartbeatCallback = (createClient as jest.Mock).mock.calls[
+            createClientCallsBefore - 1
+         ][2].realtime.heartbeatCallback
+
+         heartbeatCallback('disconnected')
+
+         // Should attempt reconnection (call createClient again)
+         expect((createClient as jest.Mock).mock.calls.length).toBeGreaterThan(
+            createClientCallsBefore
+         )
+      })
+
+      it('should exit on "disconnected" by default', () => {
+         expect(() => heartbeatCallback('disconnected')).toThrow(
+            'process.exit called'
+         )
+         expect(processExitSpy).toHaveBeenCalledWith(1)
+      })
+
+      it('should exit on "disconnected" when exitOnDisconnect is true', () => {
+         wrapper = new SupabaseCloudWrapper({
+            url: 'https://test.supabase.co',
+            key: 'test-key',
+            exitOnDisconnect: true,
+         })
+
+         heartbeatCallback = (createClient as jest.Mock).mock.calls[1][2]
+            .realtime.heartbeatCallback
+
+         expect(() => heartbeatCallback('disconnected')).toThrow(
+            'process.exit called'
+         )
+         expect(processExitSpy).toHaveBeenCalledWith(1)
+      })
+   })
+
+   describe('Connection Timeout', () => {
+      it('should exit if heartbeat not received within 30 seconds', () => {
+         wrapper = new SupabaseCloudWrapper({
+            url: 'https://test.supabase.co',
+            key: 'test-key',
+         })
+
+         expect(() => jest.advanceTimersByTime(30000)).toThrow(
+            'process.exit called'
+         )
+         expect(processExitSpy).toHaveBeenCalledWith(1)
+      })
+
+      it('should not exit if heartbeat received before timeout', () => {
+         wrapper = new SupabaseCloudWrapper({
+            url: 'https://test.supabase.co',
+            key: 'test-key',
+         })
+
+         heartbeatCallback('ok')
+
+         expect(() => jest.advanceTimersByTime(30000)).not.toThrow()
+         expect(processExitSpy).not.toHaveBeenCalled()
+      })
+   })
+
+   describe('databaseTrigger()', () => {
+      beforeEach(() => {
+         wrapper = new SupabaseCloudWrapper({
+            url: 'https://test.supabase.co',
+            key: 'test-key',
+         })
+         heartbeatCallback('ok') // Simulate successful connection
+      })
+
+      it('should set up single event trigger', () => {
+         const trigger: DatabaseTriggerType = {
+            name: 'test-trigger',
+            event: BackendAction.CREATE,
+            script: jest.fn(),
+            model: 'users',
+            path: '/users/{id}',
+            schema: 'public',
+         }
+
+         wrapper.databaseTrigger(trigger)
+
+         expect(mockChannel).toHaveBeenCalledWith('test-trigger')
+         expect(mockOn).toHaveBeenCalledWith(
+            'postgres_changes',
+            {
+               event: 'INSERT',
+               schema: 'public',
+               table: 'users',
+            },
+            expect.any(Function)
+         )
+         expect(mockSubscribe).toHaveBeenCalled()
+      })
+
+      it('should use default schema if not provided', () => {
+         const trigger: DatabaseTriggerType = {
+            name: 'test-trigger',
+            event: BackendAction.UPDATE,
+            script: jest.fn(),
+            model: 'posts',
+            path: '/posts/{id}',
+         }
+
+         wrapper.databaseTrigger(trigger)
+
+         expect(mockOn).toHaveBeenCalledWith(
+            'postgres_changes',
+            expect.objectContaining({
+               schema: 'public',
+            }),
+            expect.any(Function)
+         )
+      })
+
+      it('should handle multiple events', () => {
+         const trigger: DatabaseTriggerType = {
+            name: 'multi-trigger',
+            event: [BackendAction.CREATE, BackendAction.UPDATE],
+            script: jest.fn(),
+            model: 'comments',
+            path: '/comments/{id}',
+         }
+
+         wrapper.databaseTrigger(trigger)
+
+         expect(mockChannel).toHaveBeenCalledWith('multi-trigger-create')
+         expect(mockChannel).toHaveBeenCalledWith('multi-trigger-update')
+         expect(mockSubscribe).toHaveBeenCalledTimes(2)
+      })
+
+      it('should throw TypeError if script is not a function', () => {
+         const trigger: any = {
+            name: 'bad-trigger',
+            event: BackendAction.CREATE,
+            script: 'not-a-function',
+            model: 'users',
+            path: '/users/{id}',
+         }
+
+         expect(() => wrapper.databaseTrigger(trigger)).toThrow(TypeError)
+         expect(() => wrapper.databaseTrigger(trigger)).toThrow(
+            'Passed script value is not a function'
+         )
+      })
+
+      it('should execute script with payload when event fires', async () => {
+         const scriptMock = jest.fn().mockResolvedValue(undefined)
+         const trigger: DatabaseTriggerType = {
+            name: 'test-trigger',
+            event: BackendAction.CREATE,
+            script: scriptMock,
+            model: 'users',
+            path: '/users/{id}',
+         }
+
+         wrapper.databaseTrigger(trigger)
+
+         // Get the callback passed to .on()
+         const callback = mockOn.mock.calls[0][2]
+
+         const payload = {
+            old: { id: 1, name: 'old' },
+            new: { id: 1, name: 'new' },
+            extra: 'context',
+         }
+
+         await callback(payload)
+
+         expect(scriptMock).toHaveBeenCalledWith({
+            before: payload.old,
+            after: payload.new,
+            context: { extra: 'context' },
+         })
+      })
+   })
+
+   describe('storageTrigger()', () => {
+      beforeEach(() => {
+         wrapper = new SupabaseCloudWrapper({
+            url: 'https://test.supabase.co',
+            key: 'test-key',
+         })
+         heartbeatCallback('ok')
+      })
+
+      it('should set up single event storage trigger', () => {
+         const trigger: StorageTriggerType = {
+            name: 'storage-trigger',
+            event: BackendAction.CREATE,
+            script: jest.fn(),
+         }
+
+         wrapper.storageTrigger(trigger)
+
+         expect(mockChannel).toHaveBeenCalledWith('storage-trigger')
+         expect(mockOn).toHaveBeenCalledWith(
+            'postgres_changes',
+            {
+               event: 'INSERT',
+               schema: 'storage',
+               table: 'objects',
+            },
+            expect.any(Function)
+         )
+         expect(mockSubscribe).toHaveBeenCalled()
+      })
+
+      it('should handle multiple events', () => {
+         const trigger: StorageTriggerType = {
+            name: 'multi-storage',
+            event: [BackendAction.CREATE, BackendAction.DELETE],
+            script: jest.fn(),
+         }
+
+         wrapper.storageTrigger(trigger)
+
+         expect(mockChannel).toHaveBeenCalledWith('multi-storage-create')
+         expect(mockChannel).toHaveBeenCalledWith('multi-storage-delete')
+         expect(mockSubscribe).toHaveBeenCalledTimes(2)
+      })
+
+      it('should throw TypeError if script is not a function', () => {
+         const trigger: any = {
+            name: 'bad-storage',
+            event: BackendAction.CREATE,
+            script: 123,
+         }
+
+         expect(() => wrapper.storageTrigger(trigger)).toThrow(TypeError)
+      })
+
+      it('should transform payload and execute script', async () => {
+         const scriptMock = jest.fn().mockResolvedValue(undefined)
+         const trigger: StorageTriggerType = {
+            name: 'storage-trigger',
+            event: BackendAction.CREATE,
+            script: scriptMock,
+         }
+
+         wrapper.storageTrigger(trigger)
+
+         const callback = mockOn.mock.calls[0][2]
+
+         const payload = {
+            old: {},
+            new: {
+               bucket_id: 'uploads',
+               name: 'test.jpg',
+               metadata: { size: 1024, mimetype: 'image/jpeg' },
+            },
+            context: 'test-context',
+         }
+
+         await callback(payload)
+
+         expect(scriptMock).toHaveBeenCalledWith({
+            before: undefined,
+            after: {
+               host: 'supabase',
+               bucket: 'uploads',
+               ref: 'test.jpg',
+               contentType: 'image/jpeg',
+               size: 1024,
+            },
+            context: { context: 'test-context' },
+         })
+      })
+   })
+
+   describe('_payload2File()', () => {
+      beforeEach(() => {
+         wrapper = new SupabaseCloudWrapper({
+            url: 'https://test.supabase.co',
+            key: 'test-key',
+         })
+      })
+
+      it('should convert valid payload to FileType', () => {
+         const payload = {
+            bucket_id: 'avatars',
+            name: 'profile.png',
+            metadata: {
+               size: 2048,
+               mimetype: 'image/png',
+            },
+         }
+
+         const result = (wrapper as any)._payload2File(payload)
+
+         expect(result).toEqual({
+            host: 'supabase',
+            bucket: 'avatars',
+            ref: 'profile.png',
+            contentType: 'image/png',
+            size: 2048,
+         })
+      })
+
+      it('should return undefined for payload without metadata', () => {
+         const payload = {
+            bucket_id: 'uploads',
+            name: 'file.txt',
+         }
+
+         const result = (wrapper as any)._payload2File(payload)
+
+         expect(result).toBeUndefined()
+      })
+
+      it('should return undefined for empty payload', () => {
+         const payload = {}
+
+         const result = (wrapper as any)._payload2File(payload)
+
+         expect(result).toBeUndefined()
+      })
+
+      it('should handle missing size or mimetype', () => {
+         const payload = {
+            bucket_id: 'docs',
+            name: 'document.pdf',
+            metadata: {},
+         }
+
+         const result = (wrapper as any)._payload2File(payload)
+
+         expect(result).toEqual({
+            host: 'supabase',
+            bucket: 'docs',
+            ref: 'document.pdf',
+            contentType: undefined,
+            size: undefined,
+         })
+      })
+   })
+
+   describe('Module Exports', () => {
+      it('should export SupabaseCloudWrapper', () => {
+         expect(SupabaseCloudWrapper).toBeDefined()
+         expect(typeof SupabaseCloudWrapper).toBe('function')
+      })
+
+      it('should export eventMap', () => {
+         expect(eventMap).toBeDefined()
+         expect(typeof eventMap).toBe('object')
+      })
+   })
+})

package/src/SupabaseCloudWrapper.ts

@@ -6,15 +6,12 @@ import {
    StorageEventPayloadType,
 } from '@quatrain/cloudwrapper'
 import { BackendAction } from '@quatrain/backend'
-import {
-   createClient,
-   SupabaseClient,
-   RealtimeChannel,
-} from '@supabase/supabase-js'
-import { HeartbeatStatus } from '@supabase/realtime-js/dist/module/RealtimeClient'
+import { createClient, SupabaseClient } from '@supabase/supabase-js'
 import ws from 'ws'
 import { FileType } from '@quatrain/storage'
 
+type HeartbeatStatus = 'sent' | 'ok' | 'error' | 'timeout' | 'disconnected'
+
 export type SupabaseParams = {
    useEmulator?: boolean
    url?: string
@@ -22,17 +19,6 @@ export type SupabaseParams = {
    exitOnDisconnect?: boolean
 }
 
-export type Channel = {
-   name: string
-   channel: RealtimeChannel | undefined
-   state: any
-}
-
-export type Channels = {
-   database: Channel[]
-   storage: Channel[]
-}
-
 export const eventMap = {
    [BackendAction.CREATE]: 'INSERT',
    [BackendAction.UPDATE]: 'UPDATE',
@@ -41,11 +27,9 @@ export const eventMap = {
 
 export class SupabaseCloudWrapper extends AbstractCloudWrapper {
    protected _supabaseClient: SupabaseClient | undefined
-   protected _realtimeClient: RealtimeChannel | undefined
    protected _isInitialized = false
    protected _heartbeatOkReceived = false
    protected _connectionTimeout: NodeJS.Timeout | undefined
-   protected _channels: Channels = { database: [], storage: [] }
 
    constructor(params: SupabaseParams) {
       super(params)
@@ -56,11 +40,11 @@ export class SupabaseCloudWrapper extends AbstractCloudWrapper {
       this._initialize()
 
       if (!(this._supabaseClient instanceof SupabaseClient)) {
-         throw new Error(`Realtime channel is not enabled`)
+         throw new TypeError(`Supabase client is not enabled`)
       }
 
       if (typeof trigger.script !== 'function') {
-         throw new Error(`Passed script value is not a function`)
+         throw new TypeError(`Passed script value is not a function`)
       }
 
       if (Array.isArray(trigger.event)) {
@@ -81,10 +65,11 @@ export class SupabaseCloudWrapper extends AbstractCloudWrapper {
             schema,
             table: trigger.model,
          }
+
          CloudWrapper.info(
             `Set up DB trigger ${trigger.name} for ${trigger.event} event on table ${schema}.${params.table}`
          )
-         const channel = this._supabaseClient
+         this._supabaseClient
             ?.channel(trigger.name)
             .on(
                'postgres_changes',
@@ -102,11 +87,6 @@ export class SupabaseCloudWrapper extends AbstractCloudWrapper {
                }
             )
             .subscribe()
-         this._channels.database.push({
-            name: trigger.name,
-            channel,
-            state: channel.state,
-         })
 
          return params
       } catch (err) {
@@ -143,7 +123,7 @@ export class SupabaseCloudWrapper extends AbstractCloudWrapper {
          CloudWrapper.info(
             `Set up Storage trigger ${trigger.name} for ${trigger.event} event`
          )
-         const channel = this._supabaseClient
+         this._supabaseClient
             ?.channel(trigger.name)
             .on(
                'postgres_changes',
@@ -166,11 +146,7 @@ export class SupabaseCloudWrapper extends AbstractCloudWrapper {
                }
             )
             .subscribe()
-         this._channels.storage.push({
-            name: trigger.name,
-            channel,
-            state: channel?.state,
-         })
+
          return params
       } catch (err) {
          console.log(err)
@@ -207,15 +183,12 @@ export class SupabaseCloudWrapper extends AbstractCloudWrapper {
                            }
                            break
                         case 'timeout':
-                           CloudWrapper.warn(
-                              `⚠️ Supabase Realtime connection timed out`
-                           )
-                           break
+                        case 'error':
                         case 'disconnected':
                            // Reconnect only if exitOnDisconnect is explicitly set to false.
                            if (this._params.exitOnDisconnect === false) {
                               CloudWrapper.warn(
-                                 `❌ Supabase connection lost. Attempting to reconnect...`
+                                 `❌ Supabase connection lost (status: ${status}). Attempting to reconnect...`
                               )
                               this._isInitialized = false
                               this._heartbeatOkReceived = false
@@ -223,7 +196,7 @@ export class SupabaseCloudWrapper extends AbstractCloudWrapper {
                            } else {
                               // Default behavior: exit to allow for a clean restart by the orchestrator.
                               CloudWrapper.error(
-                                 `❌ Supabase connection lost. Exiting to allow for a clean restart.`
+                                 `❌ Supabase connection lost (status: ${status}). Exiting to allow for a clean restart.`
                               )
                               process.exit(1)
                            }