@quatrain/cloudwrapper-supabase 1.1.26 → 1.1.27

package/dist/SupabaseCloudWrapper.d.ts

@@ -0,0 +1,36 @@
+/// <reference types="node" />
+import { AbstractCloudWrapper, DatabaseTriggerType, StorageTriggerType } from '@quatrain/cloudwrapper';
+import { SupabaseClient } from '@supabase/supabase-js';
+import { FileType } from '@quatrain/storage';
+export type SupabaseParams = {
+    useEmulator?: boolean;
+    url?: string;
+    key?: string;
+    exitOnDisconnect?: boolean;
+};
+export declare const eventMap: {
+    create: string;
+    update: string;
+    delete: string;
+};
+export declare class SupabaseCloudWrapper extends AbstractCloudWrapper {
+    protected _supabaseClient: SupabaseClient | undefined;
+    protected _isInitialized: boolean;
+    protected _heartbeatOkReceived: boolean;
+    protected _connectionTimeout: NodeJS.Timeout | undefined;
+    constructor(params: SupabaseParams);
+    databaseTrigger(trigger: DatabaseTriggerType): void | {
+        event: any;
+        schema: string;
+        table: string;
+    };
+    storageTrigger(trigger: StorageTriggerType): void | {
+        event: any;
+        schema: string;
+        table: string;
+    };
+    protected _initialize(): void;
+    protected _payload2File(payload: {
+        [x: string]: any;
+    }): FileType | undefined;
+}

package/dist/SupabaseCloudWrapper.js

@@ -0,0 +1,198 @@
+"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());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SupabaseCloudWrapper = exports.eventMap = void 0;
+const cloudwrapper_1 = require("@quatrain/cloudwrapper");
+const backend_1 = require("@quatrain/backend");
+const supabase_js_1 = require("@supabase/supabase-js");
+const ws_1 = __importDefault(require("ws"));
+exports.eventMap = {
+    [backend_1.BackendAction.CREATE]: 'INSERT',
+    [backend_1.BackendAction.UPDATE]: 'UPDATE',
+    [backend_1.BackendAction.DELETE]: 'DELETE',
+};
+class SupabaseCloudWrapper extends cloudwrapper_1.AbstractCloudWrapper {
+    constructor(params) {
+        super(params);
+        this._isInitialized = false;
+        this._heartbeatOkReceived = false;
+        this._initialize();
+    }
+    databaseTrigger(trigger) {
+        var _a;
+        this._initialize();
+        if (!(this._supabaseClient instanceof supabase_js_1.SupabaseClient)) {
+            throw new TypeError(`Supabase client is not enabled`);
+        }
+        if (typeof trigger.script !== 'function') {
+            throw new TypeError(`Passed script value is not a function`);
+        }
+        if (Array.isArray(trigger.event)) {
+            const params = trigger.event.forEach((event) => {
+                return this.databaseTrigger(Object.assign(Object.assign({}, trigger), { event, name: `${trigger.name}-${event}` }));
+            });
+            return params;
+        }
+        try {
+            const schema = trigger.schema || 'public';
+            const params = {
+                event: Reflect.get(exports.eventMap, trigger.event),
+                schema,
+                table: trigger.model,
+            };
+            cloudwrapper_1.CloudWrapper.info(`Set up DB trigger ${trigger.name} for ${trigger.event} event on table ${schema}.${params.table}`);
+            (_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 {
+                    return yield trigger.script({ before, after, context });
+                }
+                catch (err) {
+                    cloudwrapper_1.CloudWrapper.error(err.message);
+                    console.log(err);
+                }
+            })).subscribe();
+            return params;
+        }
+        catch (err) {
+            cloudwrapper_1.CloudWrapper.error(err);
+            throw new Error(`Realtime channel subscription failed`);
+        }
+    }
+    storageTrigger(trigger) {
+        var _a;
+        this._initialize();
+        if (typeof trigger.script !== 'function') {
+            throw new TypeError(`Passed script value is not a function`);
+        }
+        if (Array.isArray(trigger.event)) {
+            const params = trigger.event.forEach((event) => {
+                return this.storageTrigger(Object.assign(Object.assign({}, trigger), { event, name: `${trigger.name}-${event}` }));
+            });
+            return params;
+        }
+        try {
+            const params = {
+                event: Reflect.get(exports.eventMap, trigger.event),
+                schema: 'storage',
+                table: 'objects',
+            };
+            cloudwrapper_1.CloudWrapper.info(`Set up Storage trigger ${trigger.name} for ${trigger.event} event`);
+            (_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 {
+                    const payload = {
+                        before: this._payload2File(before),
+                        after: this._payload2File(after),
+                        context,
+                    };
+                    cloudwrapper_1.CloudWrapper.debug(payload);
+                    return yield trigger.script(payload);
+                }
+                catch (err) {
+                    cloudwrapper_1.CloudWrapper.error(err.message);
+                }
+            })).subscribe();
+            return params;
+        }
+        catch (err) {
+            console.log(err);
+            throw new Error(`Realtime channel subscription failed`);
+        }
+    }
+    _initialize() {
+        if (this._isInitialized === false) {
+            cloudwrapper_1.CloudWrapper.info(`Starting Supabase client with heartbeat monitoring`);
+            if (this._connectionTimeout) {
+                clearTimeout(this._connectionTimeout);
+            }
+            this._supabaseClient = (0, supabase_js_1.createClient)(this._params.url, this._params.key, {
+                realtime: {
+                    transport: ws_1.default,
+                    heartbeatIntervalMs: 5000,
+                    heartbeatCallback: (status) => {
+                        switch (status) {
+                            case 'ok':
+                                if (!this._heartbeatOkReceived) {
+                                    cloudwrapper_1.CloudWrapper.info(`🛜 Supabase Realtime connection established`);
+                                    if (this._connectionTimeout) {
+                                        clearTimeout(this._connectionTimeout);
+                                    }
+                                    this._heartbeatOkReceived = true;
+                                }
+                                break;
+                            case 'timeout':
+                            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 (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 (status: ${status}). Exiting to allow for a clean restart.`);
+                                    process.exit(1);
+                                }
+                                break;
+                            default:
+                                // do nothing
+                                break;
+                        }
+                    },
+                },
+            });
+            this._isInitialized = true;
+            cloudwrapper_1.CloudWrapper.info(`Supabase App initialized`);
+            cloudwrapper_1.CloudWrapper.info(`🕘 Supabase Realtime connection is being established`);
+            this._connectionTimeout = setTimeout(() => {
+                if (!this._heartbeatOkReceived) {
+                    cloudwrapper_1.CloudWrapper.error(`❌ Supabase Realtime connection failed to establish after 30 seconds. Exiting.`);
+                    process.exit(1);
+                }
+            }, 30000);
+        }
+    }
+    _payload2File(payload) {
+        if (!payload.metadata) {
+            return undefined;
+        }
+        if (Object.keys(payload).length === 0) {
+            return undefined;
+        }
+        const { size, mimetype } = (payload === null || payload === void 0 ? void 0 : payload.metadata) || {};
+        return {
+            host: 'supabase',
+            bucket: payload.bucket_id,
+            ref: payload.name,
+            contentType: mimetype,
+            size,
+        };
+    }
+}
+exports.SupabaseCloudWrapper = SupabaseCloudWrapper;

package/dist/SupabaseCloudWrapper.test.d.ts

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

package/dist/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/dist/index.d.ts

@@ -0,0 +1,2 @@
+import { SupabaseCloudWrapper } from './SupabaseCloudWrapper';
+export { SupabaseCloudWrapper };

package/dist/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SupabaseCloudWrapper = void 0;
+const SupabaseCloudWrapper_1 = require("./SupabaseCloudWrapper");
+Object.defineProperty(exports, "SupabaseCloudWrapper", { enumerable: true, get: function () { return SupabaseCloudWrapper_1.SupabaseCloudWrapper; } });

package/package.json

@@ -1,51 +1,51 @@
 {
-   "name": "@quatrain/cloudwrapper-supabase",
-   "version": "1.1.26",
-   "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.43"
-   },
-   "dependencies": {
-      "@quatrain/backend": "^1.1.28",
-      "@quatrain/cloudwrapper": "^1.1.17",
-      "@quatrain/core": "^1.1.43",
-      "@quatrain/storage": "^1.1.24",
-      "@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"
-   }
-}
+  "name": "@quatrain/cloudwrapper-supabase",
+  "version": "1.1.27",
+  "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": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bun": "src/index.ts",
+  "files": [
+    "LICENSE.md",
+    "src/",
+    "dist/",
+    "README.md"
+  ],
+  "author": "Quatrain Développement SAS <developers@quatrain.com>",
+  "peerDependencies": {
+    "@quatrain/core": "^1.1.44"
+  },
+  "dependencies": {
+    "@quatrain/backend": "^1.1.29",
+    "@quatrain/cloudwrapper": "^1.1.18",
+    "@quatrain/core": "^1.1.44",
+    "@quatrain/storage": "^1.1.24",
+    "@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"
+  }
+}