@kywi-software/core 0.7.1 → 0.8.0

package/dist/db/__tests__/extension-queries.test.js

@@ -1,823 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { createSubtype, updateSubtype, deleteSubtype, listSubtypes, createAttributeSet, updateAttributeSet, deleteAttributeSet, listAttributeSets, createAttribute, updateAttribute, deleteAttribute, listAttributes, getExtendedData, setExtendedValue, clearExtendedData, getRelatedSetData, addRelatedSetRow, updateRelatedSetRow, removeRelatedSetRow, reorderRelatedSetRows, } from '../extension-queries.js';
-// ─────────────────────────────────────────────────────────────────────────────
-// Fixtures
-// ─────────────────────────────────────────────────────────────────────────────
-const SUBTYPE_ID = 'subtype-uuid-1';
-const SET_ID = 'set-uuid-1';
-const ATTR_ID = 'attr-uuid-1';
-const CONTENT_ID = 'content-uuid-1';
-const DATA_ID = 'data-uuid-1';
-const RELATED_ID = 'related-uuid-1';
-const mockSubtypeRow = {
-    id: SUBTYPE_ID,
-    name: 'Real Estate Listing',
-    baseContentType: 'content',
-    description: 'Custom fields for real estate',
-    isActive: true,
-    createdAt: new Date(),
-};
-const mockSetRow = {
-    id: SET_ID,
-    subtypeId: SUBTYPE_ID,
-    name: 'property_details',
-    label: 'Property Details',
-    sortOrder: 0,
-    createdAt: new Date(),
-};
-const mockAttributeRow = {
-    id: ATTR_ID,
-    setId: SET_ID,
-    name: 'price',
-    label: 'Listing Price',
-    type: 'number',
-    defaultValue: null,
-    validation: { required: true, min: 0 },
-    sortOrder: 0,
-    createdAt: new Date(),
-};
-const mockDataRow = {
-    id: DATA_ID,
-    contentId: CONTENT_ID,
-    attributeId: ATTR_ID,
-    stringValue: null,
-    numberValue: '450000.000000',
-    dateValue: null,
-    booleanValue: null,
-    jsonValue: null,
-    createdAt: new Date(),
-    updatedAt: new Date(),
-};
-const mockRelatedRow = {
-    id: RELATED_ID,
-    contentId: CONTENT_ID,
-    setId: SET_ID,
-    data: [{ name: 'Bedrooms', value: '3', unit: 'rooms' }],
-    sortOrder: 0,
-    createdAt: new Date(),
-};
-// ─────────────────────────────────────────────────────────────────────────────
-// Mock DB factory
-// ─────────────────────────────────────────────────────────────────────────────
-function makeMockDb() {
-    return {
-        insert: vi.fn(),
-        update: vi.fn(),
-        delete: vi.fn(),
-        select: vi.fn(),
-    };
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// Schema import test
-// ─────────────────────────────────────────────────────────────────────────────
-describe('Extension schema tables', () => {
-    it('imports all 5 tables without errors', async () => {
-        const schema = await import('../../schema/extensions.js');
-        expect(schema.kywiExtendSubtypes).toBeDefined();
-        expect(schema.kywiExtendSets).toBeDefined();
-        expect(schema.kywiExtendAttributes).toBeDefined();
-        expect(schema.kywiExtendData).toBeDefined();
-        expect(schema.kywiExtendRelatedSets).toBeDefined();
-    });
-    it('exports getValueColumn and returns correct columns', async () => {
-        const { getValueColumn } = await import('../../schema/extensions.js');
-        expect(getValueColumn('text')).toBe('stringValue');
-        expect(getValueColumn('number')).toBe('numberValue');
-        expect(getValueColumn('date')).toBe('dateValue');
-        expect(getValueColumn('boolean')).toBe('booleanValue');
-        expect(getValueColumn('json')).toBe('jsonValue');
-        expect(getValueColumn('select')).toBe('stringValue');
-        expect(getValueColumn('file')).toBe('stringValue');
-        expect(getValueColumn('richText')).toBe('stringValue');
-    });
-});
-// ─────────────────────────────────────────────────────────────────────────────
-// Subtype CRUD
-// ─────────────────────────────────────────────────────────────────────────────
-describe('createSubtype', () => {
-    let db;
-    beforeEach(() => {
-        db = makeMockDb();
-        vi.clearAllMocks();
-    });
-    it('calls insert and returns the created row', async () => {
-        db.insert.mockReturnValue({
-            values: vi.fn().mockReturnValue({
-                returning: vi.fn().mockResolvedValue([mockSubtypeRow]),
-            }),
-        });
-        const result = await createSubtype(db, {
-            name: 'Real Estate Listing',
-            baseContentType: 'content',
-            description: 'Custom fields for real estate',
-        });
-        expect(db.insert).toHaveBeenCalledTimes(1);
-        expect(result).toEqual(mockSubtypeRow);
-    });
-    it('defaults isActive to true and description to null', async () => {
-        const valuesMock = vi.fn().mockReturnValue({
-            returning: vi.fn().mockResolvedValue([mockSubtypeRow]),
-        });
-        db.insert.mockReturnValue({ values: valuesMock });
-        await createSubtype(db, {
-            name: 'Test',
-            baseContentType: 'content',
-        });
-        expect(valuesMock).toHaveBeenCalledWith(expect.objectContaining({ isActive: true, description: null }));
-    });
-});
-describe('updateSubtype', () => {
-    let db;
-    beforeEach(() => {
-        db = makeMockDb();
-        vi.clearAllMocks();
-    });
-    it('calls update and returns the updated row', async () => {
-        db.update.mockReturnValue({
-            set: vi.fn().mockReturnValue({
-                where: vi.fn().mockReturnValue({
-                    returning: vi.fn().mockResolvedValue([mockSubtypeRow]),
-                }),
-            }),
-        });
-        const result = await updateSubtype(db, SUBTYPE_ID, { name: 'Updated Name' });
-        expect(db.update).toHaveBeenCalledTimes(1);
-        expect(result).toEqual(mockSubtypeRow);
-    });
-    it('returns null when subtype does not exist', async () => {
-        db.update.mockReturnValue({
-            set: vi.fn().mockReturnValue({
-                where: vi.fn().mockReturnValue({
-                    returning: vi.fn().mockResolvedValue([]),
-                }),
-            }),
-        });
-        const result = await updateSubtype(db, 'nonexistent', { name: 'x' });
-        expect(result).toBeNull();
-    });
-});
-describe('deleteSubtype', () => {
-    let db;
-    beforeEach(() => {
-        db = makeMockDb();
-        vi.clearAllMocks();
-    });
-    it('returns true when subtype existed and was deleted', async () => {
-        db.delete.mockReturnValue({
-            where: vi.fn().mockReturnValue({
-                returning: vi.fn().mockResolvedValue([{ id: SUBTYPE_ID }]),
-            }),
-        });
-        const result = await deleteSubtype(db, SUBTYPE_ID);
-        expect(result).toBe(true);
-    });
-    it('returns false when subtype did not exist', async () => {
-        db.delete.mockReturnValue({
-            where: vi.fn().mockReturnValue({
-                returning: vi.fn().mockResolvedValue([]),
-            }),
-        });
-        const result = await deleteSubtype(db, 'nonexistent');
-        expect(result).toBe(false);
-    });
-});
-describe('listSubtypes', () => {
-    let db;
-    beforeEach(() => {
-        db = makeMockDb();
-        vi.clearAllMocks();
-    });
-    it('returns all subtypes ordered by name', async () => {
-        db.select.mockReturnValue({
-            from: vi.fn().mockReturnValue({
-                orderBy: vi.fn().mockResolvedValue([mockSubtypeRow]),
-            }),
-        });
-        const result = await listSubtypes(db);
-        expect(db.select).toHaveBeenCalledTimes(1);
-        expect(result).toEqual([mockSubtypeRow]);
-    });
-});
-// ─────────────────────────────────────────────────────────────────────────────
-// Attribute Set CRUD
-// ─────────────────────────────────────────────────────────────────────────────
-describe('createAttributeSet', () => {
-    let db;
-    beforeEach(() => {
-        db = makeMockDb();
-        vi.clearAllMocks();
-    });
-    it('calls insert with subtypeId and returns the created row', async () => {
-        const valuesMock = vi.fn().mockReturnValue({
-            returning: vi.fn().mockResolvedValue([mockSetRow]),
-        });
-        db.insert.mockReturnValue({ values: valuesMock });
-        const result = await createAttributeSet(db, {
-            subtypeId: SUBTYPE_ID,
-            name: 'property_details',
-            label: 'Property Details',
-        });
-        expect(db.insert).toHaveBeenCalledTimes(1);
-        expect(valuesMock).toHaveBeenCalledWith(expect.objectContaining({ subtypeId: SUBTYPE_ID }));
-        expect(result).toEqual(mockSetRow);
-    });
-    it('defaults sortOrder to 0', async () => {
-        const valuesMock = vi.fn().mockReturnValue({
-            returning: vi.fn().mockResolvedValue([mockSetRow]),
-        });
-        db.insert.mockReturnValue({ values: valuesMock });
-        await createAttributeSet(db, {
-            subtypeId: SUBTYPE_ID,
-            name: 'test',
-            label: 'Test',
-        });
-        expect(valuesMock).toHaveBeenCalledWith(expect.objectContaining({ sortOrder: 0 }));
-    });
-});
-describe('updateAttributeSet', () => {
-    let db;
-    beforeEach(() => {
-        db = makeMockDb();
-        vi.clearAllMocks();
-    });
-    it('returns the updated row', async () => {
-        db.update.mockReturnValue({
-            set: vi.fn().mockReturnValue({
-                where: vi.fn().mockReturnValue({
-                    returning: vi.fn().mockResolvedValue([mockSetRow]),
-                }),
-            }),
-        });
-        const result = await updateAttributeSet(db, SET_ID, { label: 'New Label' });
-        expect(result).toEqual(mockSetRow);
-    });
-    it('returns null when set does not exist', async () => {
-        db.update.mockReturnValue({
-            set: vi.fn().mockReturnValue({
-                where: vi.fn().mockReturnValue({
-                    returning: vi.fn().mockResolvedValue([]),
-                }),
-            }),
-        });
-        const result = await updateAttributeSet(db, 'nonexistent', { label: 'x' });
-        expect(result).toBeNull();
-    });
-});
-describe('deleteAttributeSet', () => {
-    let db;
-    beforeEach(() => {
-        db = makeMockDb();
-        vi.clearAllMocks();
-    });
-    it('returns true when set existed', async () => {
-        db.delete.mockReturnValue({
-            where: vi.fn().mockReturnValue({
-                returning: vi.fn().mockResolvedValue([{ id: SET_ID }]),
-            }),
-        });
-        expect(await deleteAttributeSet(db, SET_ID)).toBe(true);
-    });
-    it('returns false when set did not exist', async () => {
-        db.delete.mockReturnValue({
-            where: vi.fn().mockReturnValue({
-                returning: vi.fn().mockResolvedValue([]),
-            }),
-        });
-        expect(await deleteAttributeSet(db, 'nonexistent')).toBe(false);
-    });
-});
-describe('listAttributeSets', () => {
-    let db;
-    beforeEach(() => {
-        db = makeMockDb();
-        vi.clearAllMocks();
-    });
-    it('filters by subtypeId and orders by sortOrder', async () => {
-        const orderByMock = vi.fn().mockResolvedValue([mockSetRow]);
-        const whereMock = vi.fn().mockReturnValue({ orderBy: orderByMock });
-        db.select.mockReturnValue({
-            from: vi.fn().mockReturnValue({ where: whereMock }),
-        });
-        const result = await listAttributeSets(db, SUBTYPE_ID);
-        expect(db.select).toHaveBeenCalledTimes(1);
-        expect(whereMock).toHaveBeenCalledTimes(1);
-        expect(result).toEqual([mockSetRow]);
-    });
-});
-// ─────────────────────────────────────────────────────────────────────────────
-// Attribute CRUD
-// ─────────────────────────────────────────────────────────────────────────────
-describe('createAttribute', () => {
-    let db;
-    beforeEach(() => {
-        db = makeMockDb();
-        vi.clearAllMocks();
-    });
-    it('calls insert with setId and validation JSON', async () => {
-        const valuesMock = vi.fn().mockReturnValue({
-            returning: vi.fn().mockResolvedValue([mockAttributeRow]),
-        });
-        db.insert.mockReturnValue({ values: valuesMock });
-        const result = await createAttribute(db, {
-            setId: SET_ID,
-            name: 'price',
-            label: 'Listing Price',
-            type: 'number',
-            validation: { required: true, min: 0 },
-        });
-        expect(db.insert).toHaveBeenCalledTimes(1);
-        expect(valuesMock).toHaveBeenCalledWith(expect.objectContaining({
-            setId: SET_ID,
-            type: 'number',
-            validation: { required: true, min: 0 },
-        }));
-        expect(result).toEqual(mockAttributeRow);
-    });
-    it('defaults validation and defaultValue to null', async () => {
-        const valuesMock = vi.fn().mockReturnValue({
-            returning: vi.fn().mockResolvedValue([mockAttributeRow]),
-        });
-        db.insert.mockReturnValue({ values: valuesMock });
-        await createAttribute(db, {
-            setId: SET_ID,
-            name: 'title',
-            label: 'Title',
-            type: 'text',
-        });
-        expect(valuesMock).toHaveBeenCalledWith(expect.objectContaining({ defaultValue: null, validation: null }));
-    });
-});
-describe('updateAttribute', () => {
-    let db;
-    beforeEach(() => {
-        db = makeMockDb();
-        vi.clearAllMocks();
-    });
-    it('returns the updated row', async () => {
-        db.update.mockReturnValue({
-            set: vi.fn().mockReturnValue({
-                where: vi.fn().mockReturnValue({
-                    returning: vi.fn().mockResolvedValue([mockAttributeRow]),
-                }),
-            }),
-        });
-        const result = await updateAttribute(db, ATTR_ID, { label: 'New Label' });
-        expect(result).toEqual(mockAttributeRow);
-    });
-    it('returns null when attribute does not exist', async () => {
-        db.update.mockReturnValue({
-            set: vi.fn().mockReturnValue({
-                where: vi.fn().mockReturnValue({
-                    returning: vi.fn().mockResolvedValue([]),
-                }),
-            }),
-        });
-        const result = await updateAttribute(db, 'nonexistent', { label: 'x' });
-        expect(result).toBeNull();
-    });
-});
-describe('deleteAttribute', () => {
-    let db;
-    beforeEach(() => {
-        db = makeMockDb();
-        vi.clearAllMocks();
-    });
-    it('returns true when attribute existed', async () => {
-        db.delete.mockReturnValue({
-            where: vi.fn().mockReturnValue({
-                returning: vi.fn().mockResolvedValue([{ id: ATTR_ID }]),
-            }),
-        });
-        expect(await deleteAttribute(db, ATTR_ID)).toBe(true);
-    });
-    it('returns false when attribute did not exist', async () => {
-        db.delete.mockReturnValue({
-            where: vi.fn().mockReturnValue({
-                returning: vi.fn().mockResolvedValue([]),
-            }),
-        });
-        expect(await deleteAttribute(db, 'nonexistent')).toBe(false);
-    });
-});
-describe('listAttributes', () => {
-    let db;
-    beforeEach(() => {
-        db = makeMockDb();
-        vi.clearAllMocks();
-    });
-    it('filters by setId and orders by sortOrder', async () => {
-        const orderByMock = vi.fn().mockResolvedValue([mockAttributeRow]);
-        const whereMock = vi.fn().mockReturnValue({ orderBy: orderByMock });
-        db.select.mockReturnValue({
-            from: vi.fn().mockReturnValue({ where: whereMock }),
-        });
-        const result = await listAttributes(db, SET_ID);
-        expect(db.select).toHaveBeenCalledTimes(1);
-        expect(result).toEqual([mockAttributeRow]);
-    });
-});
-// ─────────────────────────────────────────────────────────────────────────────
-// Extension Data — setExtendedValue column mapping
-// ─────────────────────────────────────────────────────────────────────────────
-describe('setExtendedValue', () => {
-    let db;
-    beforeEach(() => {
-        db = makeMockDb();
-        vi.clearAllMocks();
-    });
-    it('stores number values in numberValue column (insert path)', async () => {
-        // First select: look up attribute type
-        const attrSelectChain = {
-            from: vi.fn().mockReturnValue({
-                where: vi.fn().mockReturnValue({
-                    limit: vi.fn().mockResolvedValue([{ type: 'number' }]),
-                }),
-            }),
-        };
-        // Second select: check for existing row (none found)
-        const existingSelectChain = {
-            from: vi.fn().mockReturnValue({
-                where: vi.fn().mockReturnValue({
-                    limit: vi.fn().mockResolvedValue([]),
-                }),
-            }),
-        };
-        db.select
-            .mockReturnValueOnce(attrSelectChain)
-            .mockReturnValueOnce(existingSelectChain);
-        const valuesMock = vi.fn().mockReturnValue({
-            returning: vi.fn().mockResolvedValue([mockDataRow]),
-        });
-        db.insert.mockReturnValue({ values: valuesMock });
-        const result = await setExtendedValue(db, CONTENT_ID, ATTR_ID, 450000);
-        expect(db.insert).toHaveBeenCalledTimes(1);
-        expect(valuesMock).toHaveBeenCalledWith(expect.objectContaining({
-            contentId: CONTENT_ID,
-            attributeId: ATTR_ID,
-            numberValue: 450000,
-            stringValue: null,
-            dateValue: null,
-            booleanValue: null,
-            jsonValue: null,
-        }));
-        expect(result).toEqual(mockDataRow);
-    });
-    it('stores text values in stringValue column', async () => {
-        const attrSelectChain = {
-            from: vi.fn().mockReturnValue({
-                where: vi.fn().mockReturnValue({
-                    limit: vi.fn().mockResolvedValue([{ type: 'text' }]),
-                }),
-            }),
-        };
-        const existingSelectChain = {
-            from: vi.fn().mockReturnValue({
-                where: vi.fn().mockReturnValue({
-                    limit: vi.fn().mockResolvedValue([]),
-                }),
-            }),
-        };
-        db.select
-            .mockReturnValueOnce(attrSelectChain)
-            .mockReturnValueOnce(existingSelectChain);
-        const valuesMock = vi.fn().mockReturnValue({
-            returning: vi.fn().mockResolvedValue([{ ...mockDataRow, stringValue: 'hello', numberValue: null }]),
-        });
-        db.insert.mockReturnValue({ values: valuesMock });
-        await setExtendedValue(db, CONTENT_ID, ATTR_ID, 'hello');
-        expect(valuesMock).toHaveBeenCalledWith(expect.objectContaining({
-            stringValue: 'hello',
-            numberValue: null,
-        }));
-    });
-    it('stores boolean values in booleanValue column', async () => {
-        const attrSelectChain = {
-            from: vi.fn().mockReturnValue({
-                where: vi.fn().mockReturnValue({
-                    limit: vi.fn().mockResolvedValue([{ type: 'boolean' }]),
-                }),
-            }),
-        };
-        const existingSelectChain = {
-            from: vi.fn().mockReturnValue({
-                where: vi.fn().mockReturnValue({
-                    limit: vi.fn().mockResolvedValue([]),
-                }),
-            }),
-        };
-        db.select
-            .mockReturnValueOnce(attrSelectChain)
-            .mockReturnValueOnce(existingSelectChain);
-        const valuesMock = vi.fn().mockReturnValue({
-            returning: vi.fn().mockResolvedValue([{ ...mockDataRow, booleanValue: true, numberValue: null }]),
-        });
-        db.insert.mockReturnValue({ values: valuesMock });
-        await setExtendedValue(db, CONTENT_ID, ATTR_ID, true);
-        expect(valuesMock).toHaveBeenCalledWith(expect.objectContaining({
-            booleanValue: true,
-            stringValue: null,
-            numberValue: null,
-        }));
-    });
-    it('stores json values in jsonValue column', async () => {
-        const attrSelectChain = {
-            from: vi.fn().mockReturnValue({
-                where: vi.fn().mockReturnValue({
-                    limit: vi.fn().mockResolvedValue([{ type: 'json' }]),
-                }),
-            }),
-        };
-        const existingSelectChain = {
-            from: vi.fn().mockReturnValue({
-                where: vi.fn().mockReturnValue({
-                    limit: vi.fn().mockResolvedValue([]),
-                }),
-            }),
-        };
-        db.select
-            .mockReturnValueOnce(attrSelectChain)
-            .mockReturnValueOnce(existingSelectChain);
-        const jsonData = { features: ['pool', 'garage'] };
-        const valuesMock = vi.fn().mockReturnValue({
-            returning: vi.fn().mockResolvedValue([{ ...mockDataRow, jsonValue: jsonData, numberValue: null }]),
-        });
-        db.insert.mockReturnValue({ values: valuesMock });
-        await setExtendedValue(db, CONTENT_ID, ATTR_ID, jsonData);
-        expect(valuesMock).toHaveBeenCalledWith(expect.objectContaining({
-            jsonValue: jsonData,
-            stringValue: null,
-            numberValue: null,
-        }));
-    });
-    it('updates existing row when one exists for the content+attribute', async () => {
-        const attrSelectChain = {
-            from: vi.fn().mockReturnValue({
-                where: vi.fn().mockReturnValue({
-                    limit: vi.fn().mockResolvedValue([{ type: 'number' }]),
-                }),
-            }),
-        };
-        const existingSelectChain = {
-            from: vi.fn().mockReturnValue({
-                where: vi.fn().mockReturnValue({
-                    limit: vi.fn().mockResolvedValue([{ id: DATA_ID }]),
-                }),
-            }),
-        };
-        db.select
-            .mockReturnValueOnce(attrSelectChain)
-            .mockReturnValueOnce(existingSelectChain);
-        const setMock = vi.fn().mockReturnValue({
-            where: vi.fn().mockReturnValue({
-                returning: vi.fn().mockResolvedValue([mockDataRow]),
-            }),
-        });
-        db.update.mockReturnValue({ set: setMock });
-        const result = await setExtendedValue(db, CONTENT_ID, ATTR_ID, 500000);
-        expect(db.update).toHaveBeenCalledTimes(1);
-        expect(setMock).toHaveBeenCalledWith(expect.objectContaining({
-            numberValue: 500000,
-            stringValue: null,
-            dateValue: null,
-            booleanValue: null,
-            jsonValue: null,
-        }));
-        expect(result).toEqual(mockDataRow);
-    });
-    it('throws when attribute is not found', async () => {
-        db.select.mockReturnValue({
-            from: vi.fn().mockReturnValue({
-                where: vi.fn().mockReturnValue({
-                    limit: vi.fn().mockResolvedValue([]),
-                }),
-            }),
-        });
-        await expect(setExtendedValue(db, CONTENT_ID, 'bad-attr-id', 123)).rejects.toThrow('Attribute not found: bad-attr-id');
-    });
-});
-// ─────────────────────────────────────────────────────────────────────────────
-// getExtendedData
-// ─────────────────────────────────────────────────────────────────────────────
-describe('getExtendedData', () => {
-    let db;
-    beforeEach(() => {
-        db = makeMockDb();
-        vi.clearAllMocks();
-    });
-    it('returns joined results with attribute definitions', async () => {
-        const joinedRow = {
-            id: DATA_ID,
-            contentId: CONTENT_ID,
-            attributeId: ATTR_ID,
-            attributeName: 'price',
-            attributeLabel: 'Listing Price',
-            attributeType: 'number',
-            stringValue: null,
-            numberValue: '450000.000000',
-            dateValue: null,
-            booleanValue: null,
-            jsonValue: null,
-            createdAt: new Date(),
-            updatedAt: new Date(),
-        };
-        const whereMock = vi.fn().mockResolvedValue([joinedRow]);
-        const innerJoinMock = vi.fn().mockReturnValue({ where: whereMock });
-        const fromMock = vi.fn().mockReturnValue({ innerJoin: innerJoinMock });
-        db.select.mockReturnValue({ from: fromMock });
-        const result = await getExtendedData(db, CONTENT_ID);
-        expect(db.select).toHaveBeenCalledTimes(1);
-        expect(innerJoinMock).toHaveBeenCalledTimes(1);
-        expect(result).toEqual([joinedRow]);
-        expect(result[0].attributeName).toBe('price');
-        expect(result[0].attributeType).toBe('number');
-    });
-    it('returns empty array when no extension data exists', async () => {
-        const whereMock = vi.fn().mockResolvedValue([]);
-        const innerJoinMock = vi.fn().mockReturnValue({ where: whereMock });
-        const fromMock = vi.fn().mockReturnValue({ innerJoin: innerJoinMock });
-        db.select.mockReturnValue({ from: fromMock });
-        const result = await getExtendedData(db, 'no-data-content');
-        expect(result).toEqual([]);
-    });
-});
-// ─────────────────────────────────────────────────────────────────────────────
-// clearExtendedData
-// ─────────────────────────────────────────────────────────────────────────────
-describe('clearExtendedData', () => {
-    let db;
-    beforeEach(() => {
-        db = makeMockDb();
-        vi.clearAllMocks();
-    });
-    it('returns true when data existed and was deleted', async () => {
-        db.delete.mockReturnValue({
-            where: vi.fn().mockReturnValue({
-                returning: vi.fn().mockResolvedValue([{ id: DATA_ID }]),
-            }),
-        });
-        expect(await clearExtendedData(db, CONTENT_ID)).toBe(true);
-    });
-    it('returns false when no data existed', async () => {
-        db.delete.mockReturnValue({
-            where: vi.fn().mockReturnValue({
-                returning: vi.fn().mockResolvedValue([]),
-            }),
-        });
-        expect(await clearExtendedData(db, 'no-data')).toBe(false);
-    });
-});
-// ─────────────────────────────────────────────────────────────────────────────
-// Related Set CRUD
-// ─────────────────────────────────────────────────────────────────────────────
-describe('getRelatedSetData', () => {
-    let db;
-    beforeEach(() => {
-        db = makeMockDb();
-        vi.clearAllMocks();
-    });
-    it('filters by contentId and setId and orders by sortOrder', async () => {
-        const orderByMock = vi.fn().mockResolvedValue([mockRelatedRow]);
-        const whereMock = vi.fn().mockReturnValue({ orderBy: orderByMock });
-        db.select.mockReturnValue({
-            from: vi.fn().mockReturnValue({ where: whereMock }),
-        });
-        const result = await getRelatedSetData(db, CONTENT_ID, SET_ID);
-        expect(db.select).toHaveBeenCalledTimes(1);
-        expect(result).toEqual([mockRelatedRow]);
-    });
-});
-describe('addRelatedSetRow', () => {
-    let db;
-    beforeEach(() => {
-        db = makeMockDb();
-        vi.clearAllMocks();
-    });
-    it('inserts a row with auto-calculated sortOrder', async () => {
-        // Select for existing rows to determine sort order
-        const orderByMock = vi.fn().mockReturnValue({
-            limit: vi.fn().mockResolvedValue([{ sortOrder: 2 }]),
-        });
-        const whereMock = vi.fn().mockReturnValue({ orderBy: orderByMock });
-        db.select.mockReturnValue({
-            from: vi.fn().mockReturnValue({ where: whereMock }),
-        });
-        const valuesMock = vi.fn().mockReturnValue({
-            returning: vi.fn().mockResolvedValue([{ ...mockRelatedRow, sortOrder: 3 }]),
-        });
-        db.insert.mockReturnValue({ values: valuesMock });
-        const data = [{ name: 'Bathrooms', value: '2' }];
-        const result = await addRelatedSetRow(db, CONTENT_ID, SET_ID, data);
-        expect(db.insert).toHaveBeenCalledTimes(1);
-        expect(valuesMock).toHaveBeenCalledWith(expect.objectContaining({
-            contentId: CONTENT_ID,
-            setId: SET_ID,
-            data,
-            sortOrder: 3,
-        }));
-        expect(result.sortOrder).toBe(3);
-    });
-    it('uses sortOrder 0 when no existing rows', async () => {
-        const orderByMock = vi.fn().mockReturnValue({
-            limit: vi.fn().mockResolvedValue([]),
-        });
-        const whereMock = vi.fn().mockReturnValue({ orderBy: orderByMock });
-        db.select.mockReturnValue({
-            from: vi.fn().mockReturnValue({ where: whereMock }),
-        });
-        const valuesMock = vi.fn().mockReturnValue({
-            returning: vi.fn().mockResolvedValue([mockRelatedRow]),
-        });
-        db.insert.mockReturnValue({ values: valuesMock });
-        await addRelatedSetRow(db, CONTENT_ID, SET_ID, [{ name: 'First' }]);
-        expect(valuesMock).toHaveBeenCalledWith(expect.objectContaining({ sortOrder: 0 }));
-    });
-});
-describe('updateRelatedSetRow', () => {
-    let db;
-    beforeEach(() => {
-        db = makeMockDb();
-        vi.clearAllMocks();
-    });
-    it('updates the data column and returns the row', async () => {
-        const updatedRow = { ...mockRelatedRow, data: [{ name: 'Updated' }] };
-        db.update.mockReturnValue({
-            set: vi.fn().mockReturnValue({
-                where: vi.fn().mockReturnValue({
-                    returning: vi.fn().mockResolvedValue([updatedRow]),
-                }),
-            }),
-        });
-        const result = await updateRelatedSetRow(db, RELATED_ID, [{ name: 'Updated' }]);
-        expect(db.update).toHaveBeenCalledTimes(1);
-        expect(result).toEqual(updatedRow);
-    });
-    it('returns null when row does not exist', async () => {
-        db.update.mockReturnValue({
-            set: vi.fn().mockReturnValue({
-                where: vi.fn().mockReturnValue({
-                    returning: vi.fn().mockResolvedValue([]),
-                }),
-            }),
-        });
-        const result = await updateRelatedSetRow(db, 'nonexistent', []);
-        expect(result).toBeNull();
-    });
-});
-describe('removeRelatedSetRow', () => {
-    let db;
-    beforeEach(() => {
-        db = makeMockDb();
-        vi.clearAllMocks();
-    });
-    it('returns true when row existed', async () => {
-        db.delete.mockReturnValue({
-            where: vi.fn().mockReturnValue({
-                returning: vi.fn().mockResolvedValue([{ id: RELATED_ID }]),
-            }),
-        });
-        expect(await removeRelatedSetRow(db, RELATED_ID)).toBe(true);
-    });
-    it('returns false when row did not exist', async () => {
-        db.delete.mockReturnValue({
-            where: vi.fn().mockReturnValue({
-                returning: vi.fn().mockResolvedValue([]),
-            }),
-        });
-        expect(await removeRelatedSetRow(db, 'nonexistent')).toBe(false);
-    });
-});
-describe('reorderRelatedSetRows', () => {
-    let db;
-    beforeEach(() => {
-        db = makeMockDb();
-        vi.clearAllMocks();
-    });
-    it('updates sortOrder for each item and returns results', async () => {
-        const row1 = { ...mockRelatedRow, id: 'r1', sortOrder: 1 };
-        const row2 = { ...mockRelatedRow, id: 'r2', sortOrder: 0 };
-        db.update
-            .mockReturnValueOnce({
-            set: vi.fn().mockReturnValue({
-                where: vi.fn().mockReturnValue({
-                    returning: vi.fn().mockResolvedValue([row1]),
-                }),
-            }),
-        })
-            .mockReturnValueOnce({
-            set: vi.fn().mockReturnValue({
-                where: vi.fn().mockReturnValue({
-                    returning: vi.fn().mockResolvedValue([row2]),
-                }),
-            }),
-        });
-        const result = await reorderRelatedSetRows(db, [
-            { id: 'r1', sortOrder: 1 },
-            { id: 'r2', sortOrder: 0 },
-        ]);
-        expect(db.update).toHaveBeenCalledTimes(2);
-        expect(result).toHaveLength(2);
-        expect(result[0].sortOrder).toBe(1);
-        expect(result[1].sortOrder).toBe(0);
-    });
-});
-//# sourceMappingURL=extension-queries.test.js.map