whale-code 6.4.0 → 6.5.0

package/dist/server/handlers/__test-utils__/mock-supabase.js

@@ -1,393 +0,0 @@
-// __test-utils__/mock-supabase.ts — Reusable mock Supabase client for handler tests
-//
-// Provides an in-memory Supabase client mock with chainable query builder methods
-// that mirror the real SupabaseClient interface used by all handlers.
-import { vi } from "vitest";
-// ---------------------------------------------------------------------------
-// In-memory stores
-// ---------------------------------------------------------------------------
-/** Per-table row arrays keyed by table name */
-let tableData = {};
-/** Per-RPC function response stubs keyed by RPC name */
-let rpcResponses = {};
-/** Per-table forced errors (simulates DB failures) */
-let tableErrors = {};
-// ---------------------------------------------------------------------------
-// Public helpers
-// ---------------------------------------------------------------------------
-/** Pre-populate a table with rows for the current test */
-export function setTableData(table, rows) {
-    tableData[table] = [...rows];
-}
-/** Pre-configure the return value for an RPC call */
-export function setRpcResponse(name, data, error) {
-    rpcResponses[name] = { data: data ?? null, error: error ?? null };
-}
-/** Force a table to return an error on any operation */
-export function setTableError(table, message, code) {
-    tableErrors[table] = { message, code };
-}
-/** Reset all in-memory state between tests */
-export function resetMock() {
-    tableData = {};
-    rpcResponses = {};
-    tableErrors = {};
-}
-/** Get current in-memory rows for a table (for post-operation assertions) */
-export function getTableData(table) {
-    return tableData[table] || [];
-}
-function defaultState(table) {
-    return {
-        table,
-        selectColumns: "*",
-        filters: [],
-        orderCol: null,
-        orderAsc: true,
-        limitCount: 1000,
-        rangeFrom: null,
-        rangeTo: null,
-        isSingle: false,
-        isMaybeSingle: false,
-        isInsert: false,
-        isUpdate: false,
-        isDelete: false,
-        insertPayload: null,
-        updatePayload: null,
-        countMode: false,
-        headMode: false,
-    };
-}
-function applyFilters(rows, filters) {
-    let result = rows;
-    for (const fn of filters) {
-        result = result.filter((r) => fn(r));
-    }
-    return result;
-}
-/** Convert SQL LIKE/ILIKE pattern to regex */
-function likeToRegex(pattern, caseInsensitive) {
-    // Escape regex special chars except % and _
-    const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, (ch) => {
-        if (ch === "%" || ch === "_")
-            return ch;
-        return `\\${ch}`;
-    });
-    const regexStr = "^" + escaped.replace(/%/g, ".*").replace(/_/g, ".") + "$";
-    return new RegExp(regexStr, caseInsensitive ? "i" : "");
-}
-function buildQueryBuilder(state) {
-    const builder = {};
-    // select -----------------------------------------------------------------
-    builder.select = vi.fn((columns, opts) => {
-        state.selectColumns = columns || "*";
-        if (opts?.count)
-            state.countMode = true;
-        if (opts?.head)
-            state.headMode = true;
-        return builder;
-    });
-    // insert -----------------------------------------------------------------
-    builder.insert = vi.fn((payload) => {
-        state.isInsert = true;
-        state.insertPayload = payload;
-        return builder;
-    });
-    // update -----------------------------------------------------------------
-    builder.update = vi.fn((payload) => {
-        state.isUpdate = true;
-        state.updatePayload = payload;
-        return builder;
-    });
-    // delete -----------------------------------------------------------------
-    builder.delete = vi.fn(() => {
-        state.isDelete = true;
-        return builder;
-    });
-    // upsert -----------------------------------------------------------------
-    builder.upsert = vi.fn((payload, _opts) => {
-        state.isInsert = true;
-        state.insertPayload = payload;
-        return builder;
-    });
-    // filters ----------------------------------------------------------------
-    builder.eq = vi.fn((col, val) => {
-        state.filters.push((r) => r[col] === val);
-        return builder;
-    });
-    builder.neq = vi.fn((col, val) => {
-        state.filters.push((r) => r[col] !== val);
-        return builder;
-    });
-    builder.gt = vi.fn((col, val) => {
-        state.filters.push((r) => r[col] > val);
-        return builder;
-    });
-    builder.gte = vi.fn((col, val) => {
-        state.filters.push((r) => r[col] >= val);
-        return builder;
-    });
-    builder.lt = vi.fn((col, val) => {
-        state.filters.push((r) => r[col] < val);
-        return builder;
-    });
-    builder.lte = vi.fn((col, val) => {
-        state.filters.push((r) => r[col] <= val);
-        return builder;
-    });
-    builder.in = vi.fn((col, vals) => {
-        state.filters.push((r) => vals.includes(r[col]));
-        return builder;
-    });
-    builder.not = vi.fn((col, op, val) => {
-        state.filters.push((r) => {
-            switch (op) {
-                case "eq": return r[col] !== val;
-                case "is": return r[col] !== val;
-                case "in": return !(val || []).includes(r[col]);
-                case "like": return !likeToRegex(val, false).test(String(r[col] ?? ""));
-                case "ilike": return !likeToRegex(val, true).test(String(r[col] ?? ""));
-                default: return true;
-            }
-        });
-        return builder;
-    });
-    builder.ilike = vi.fn((col, pattern) => {
-        const re = likeToRegex(pattern, true);
-        state.filters.push((r) => re.test(String(r[col] ?? "")));
-        return builder;
-    });
-    builder.like = vi.fn((col, pattern) => {
-        const re = likeToRegex(pattern, false);
-        state.filters.push((r) => re.test(String(r[col] ?? "")));
-        return builder;
-    });
-    builder.or = vi.fn((expr) => {
-        // Parse simple PostgREST or-expressions like "status.eq.active,status.eq.draft"
-        const clauses = expr.split(",").map((c) => c.trim());
-        const parsedFilters = [];
-        for (const clause of clauses) {
-            const parts = clause.split(".");
-            if (parts.length >= 3) {
-                const col = parts[0];
-                const op = parts[1];
-                const val = parts.slice(2).join(".");
-                switch (op) {
-                    case "eq":
-                        parsedFilters.push((r) => String(r[col]) === val);
-                        break;
-                    case "neq":
-                        parsedFilters.push((r) => String(r[col]) !== val);
-                        break;
-                    case "ilike":
-                        parsedFilters.push((r) => likeToRegex(val, true).test(String(r[col] ?? "")));
-                        break;
-                    case "like":
-                        parsedFilters.push((r) => likeToRegex(val, false).test(String(r[col] ?? "")));
-                        break;
-                    case "is":
-                        parsedFilters.push((r) => {
-                            if (val === "null")
-                                return r[col] === null || r[col] === undefined;
-                            return false;
-                        });
-                        break;
-                    default:
-                        // Unknown op — pass through
-                        parsedFilters.push(() => true);
-                }
-            }
-        }
-        if (parsedFilters.length > 0) {
-            state.filters.push((r) => parsedFilters.some((fn) => fn(r)));
-        }
-        return builder;
-    });
-    builder.is = vi.fn((col, val) => {
-        state.filters.push((r) => {
-            if (val === null)
-                return r[col] === null || r[col] === undefined;
-            return r[col] === val;
-        });
-        return builder;
-    });
-    builder.contains = vi.fn((col, val) => {
-        state.filters.push((r) => {
-            const v = r[col];
-            if (Array.isArray(v) && Array.isArray(val)) {
-                return val.every((item) => v.includes(item));
-            }
-            return false;
-        });
-        return builder;
-    });
-    builder.containedBy = vi.fn((col, val) => {
-        state.filters.push((r) => {
-            const v = r[col];
-            if (Array.isArray(v) && Array.isArray(val)) {
-                return v.every((item) => val.includes(item));
-            }
-            return false;
-        });
-        return builder;
-    });
-    builder.textSearch = vi.fn((_col, _query, _opts) => {
-        // Simplified: no-op (full-text search not easily mockable)
-        return builder;
-    });
-    // ordering / limits ------------------------------------------------------
-    builder.order = vi.fn((_col, _opts) => {
-        state.orderCol = _col;
-        state.orderAsc = _opts?.ascending ?? true;
-        return builder;
-    });
-    builder.limit = vi.fn((n) => {
-        state.limitCount = n;
-        return builder;
-    });
-    builder.range = vi.fn((from, to) => {
-        state.rangeFrom = from;
-        state.rangeTo = to;
-        return builder;
-    });
-    // terminal modifiers -----------------------------------------------------
-    builder.single = vi.fn(() => {
-        state.isSingle = true;
-        return resolve(state);
-    });
-    builder.maybeSingle = vi.fn(() => {
-        state.isMaybeSingle = true;
-        return resolve(state);
-    });
-    // csv export mock --------------------------------------------------------
-    builder.csv = vi.fn(() => {
-        const rows = tableData[state.table] || [];
-        const filtered = applyFilters(rows, state.filters);
-        if (filtered.length === 0)
-            return { data: "", error: null };
-        const keys = Object.keys(filtered[0]);
-        const header = keys.join(",");
-        const lines = filtered.map((r) => keys.map((k) => String(r[k] ?? "")).join(","));
-        return { data: [header, ...lines].join("\n"), error: null };
-    });
-    // Make the builder thenable so `await sb.from(...).select(...)...` works
-    // When no terminal modifier (.single/.maybeSingle) is called, the query
-    // resolves on await.
-    builder.then = (onFulfilled, onRejected) => {
-        const result = resolve(state);
-        return Promise.resolve(result).then(onFulfilled, onRejected);
-    };
-    return builder;
-}
-/** Resolve the query against the in-memory store */
-function resolve(state) {
-    // Check for forced table errors
-    const tableError = tableErrors[state.table];
-    if (tableError) {
-        return { data: null, error: tableError };
-    }
-    const rows = tableData[state.table] || [];
-    // INSERT
-    if (state.isInsert) {
-        const payload = state.insertPayload;
-        const newRows = Array.isArray(payload) ? payload : [payload];
-        // Assign ids if missing
-        const withIds = newRows.map((r, i) => ({
-            id: `mock-id-${Date.now()}-${i}`,
-            created_at: new Date().toISOString(),
-            ...r,
-        }));
-        if (!tableData[state.table])
-            tableData[state.table] = [];
-        tableData[state.table].push(...withIds);
-        if (state.isSingle) {
-            return { data: withIds[0], error: null };
-        }
-        return { data: withIds, error: null };
-    }
-    // UPDATE
-    if (state.isUpdate) {
-        const matching = applyFilters(rows, state.filters);
-        const updated = matching.map((r) => ({ ...r, ...state.updatePayload }));
-        // Replace in store
-        tableData[state.table] = rows.map((r) => {
-            const upd = updated.find((u) => u.id === r.id);
-            return upd || r;
-        });
-        if (state.isSingle || state.isMaybeSingle) {
-            return { data: updated[0] || null, error: null };
-        }
-        return { data: updated, error: null, count: updated.length };
-    }
-    // DELETE
-    if (state.isDelete) {
-        const before = rows.length;
-        const remaining = rows.filter((r) => !state.filters.every((fn) => fn(r)));
-        tableData[state.table] = remaining;
-        const deletedCount = before - remaining.length;
-        return { data: null, error: null, count: deletedCount };
-    }
-    // SELECT
-    let filtered = applyFilters(rows, state.filters);
-    if (state.orderCol) {
-        const col = state.orderCol;
-        const asc = state.orderAsc;
-        filtered.sort((a, b) => {
-            if (a[col] < b[col])
-                return asc ? -1 : 1;
-            if (a[col] > b[col])
-                return asc ? 1 : -1;
-            return 0;
-        });
-    }
-    // Apply range before limit
-    if (state.rangeFrom !== null && state.rangeTo !== null) {
-        filtered = filtered.slice(state.rangeFrom, state.rangeTo + 1);
-    }
-    else {
-        filtered = filtered.slice(0, state.limitCount);
-    }
-    if (state.countMode && state.headMode) {
-        return { data: null, error: null, count: filtered.length };
-    }
-    if (state.isSingle) {
-        return { data: filtered[0] || null, error: filtered.length === 0 ? { message: "Row not found" } : null };
-    }
-    if (state.isMaybeSingle) {
-        return { data: filtered[0] || null, error: null };
-    }
-    return { data: filtered, error: null, count: filtered.length };
-}
-// ---------------------------------------------------------------------------
-// Main factory
-// ---------------------------------------------------------------------------
-export function createMockSupabase() {
-    const client = {
-        from: vi.fn((table) => {
-            const state = defaultState(table);
-            return buildQueryBuilder(state);
-        }),
-        rpc: vi.fn((name, params) => {
-            const resp = rpcResponses[name];
-            if (resp)
-                return Promise.resolve(resp);
-            // Default: success with null data
-            return Promise.resolve({ data: null, error: null });
-        }),
-        storage: {
-            from: vi.fn((_bucket) => ({
-                upload: vi.fn((_path, _file, _opts) => Promise.resolve({ data: { path: _path }, error: null })),
-                getPublicUrl: vi.fn((path) => ({
-                    data: { publicUrl: `https://mock-storage.test/${path}` },
-                })),
-                remove: vi.fn((_paths) => Promise.resolve({ data: _paths.map((p) => ({ name: p })), error: null })),
-                list: vi.fn((_prefix) => Promise.resolve({ data: [], error: null })),
-            })),
-        },
-        auth: {
-            getUser: vi.fn(() => Promise.resolve({ data: { user: null }, error: null })),
-            getSession: vi.fn(() => Promise.resolve({ data: { session: null }, error: null })),
-        },
-    };
-    return client;
-}