@stamhoofd/backend 2.108.0 → 2.109.0

package/src/helpers/TagHelper.test.ts

@@ -1,5 +1,5 @@
 import { OrganizationTag } from '@stamhoofd/structures';
-import { TagHelper } from './TagHelper';
+import { TagHelper } from './TagHelper.js';
 
 // todo: move tests for methods of shared package to shared package
 describe('TagHelper', () => {
@@ -123,13 +123,13 @@ describe('TagHelper', () => {
 
             // assert
             expect(result).toHaveLength(6);
-            expect(result).toInclude('id5');
-            expect(result).toInclude('id3');
-            expect(result).toInclude('id4');
-            expect(result).toInclude('id6');
-            expect(result).toInclude('id7');
-            expect(result).toInclude('id0');
-            expect(result).not.toInclude('unknownTagId');
+            expect(result).toContain('id5');
+            expect(result).toContain('id3');
+            expect(result).toContain('id4');
+            expect(result).toContain('id6');
+            expect(result).toContain('id7');
+            expect(result).toContain('id0');
+            expect(result).not.toContain('unknownTagId');
         });
     });
 
@@ -199,7 +199,7 @@ describe('TagHelper', () => {
             // assert
             expect(tag5.childTags).toHaveLength(0);
             expect(tag7.childTags).toHaveLength(3);
-            expect(tag7.childTags).not.toInclude('doesNotExist1');
+            expect(tag7.childTags).not.toContain('doesNotExist1');
         });
 
         it('should return array of tags in the correct order', () => {

package/src/helpers/outstandingBalanceJoin.ts

@@ -0,0 +1,49 @@
+import { CachedBalance, Registration } from '@stamhoofd/models';
+import { SQL, SQLAlias, SQLCalculation, SQLNamedExpression, SQLPlusSign, SQLSelectAs, SQLSum } from '@stamhoofd/sql';
+
+export const memberCachedBalanceForOrganizationJoin = SQL.leftJoin(
+    SQL.select('objectId', 'organizationId',
+        new SQLSelectAs(
+            new SQLSum(
+                SQL.column('amountOpen'),
+            ),
+            new SQLAlias('amountOpen'),
+        ),
+    )
+        .from(CachedBalance.table)
+        .where(SQL.column(CachedBalance.table, 'objectType'), 'member')
+        .groupBy(SQL.column(CachedBalance.table, 'objectId'), SQL.column(CachedBalance.table, 'organizationId')).as('memberCachedBalance') as SQLNamedExpression, 'memberCachedBalance',
+)
+    .where(SQL.column('objectId'), SQL.column(Registration.table, 'memberId'))
+    .andWhere(SQL.column('organizationId'), SQL.column(Registration.table, 'organizationId'));
+
+export const registrationCachedBalanceJoin = SQL.leftJoin(
+    SQL.select('objectId', 'organizationId',
+        new SQLSelectAs(
+            new SQLSum(
+                new SQLCalculation(
+                    SQL.column('amountOpen'),
+                    new SQLPlusSign(),
+                    SQL.column('amountPending'),
+                ),
+            ),
+            new SQLAlias('toPay'),
+        ),
+        new SQLSelectAs(
+            new SQLSum(
+                new SQLCalculation(
+                    SQL.column('amountOpen'),
+                    new SQLPlusSign(),
+                    SQL.column('amountPaid'),
+                    new SQLPlusSign(),
+                    SQL.column('amountPending'),
+                ),
+            ),
+            new SQLAlias('price'),
+        ),
+    )
+        .from(CachedBalance.table)
+        .where(SQL.column(CachedBalance.table, 'objectType'), 'registration')
+        .groupBy(SQL.column(CachedBalance.table, 'objectId'), SQL.column(CachedBalance.table, 'organizationId')).as('registrationCachedBalance') as SQLNamedExpression, 'registrationCachedBalance',
+)
+    .where(SQL.column('objectId'), SQL.column(Registration.table, 'id'));

package/src/seeds/1765896674-document-update-year.test.ts

@@ -0,0 +1,179 @@
+import { DocumentTemplate, DocumentTemplateFactory, GroupFactory, OrganizationFactory, RegistrationPeriod, RegistrationPeriodFactory } from '@stamhoofd/models';
+import { migrateDocumentYears } from './1765896674-document-update-year.js';
+
+describe('migration.document-update-year', () => {
+    describe('should use most frequent year of groups', () => {
+        test('groups with date in period', async () => {
+            const organization = await new OrganizationFactory({
+            }).create();
+
+            const period1 = await new RegistrationPeriodFactory({
+                startDate: new Date(2021, 0, 1),
+                endDate: new Date(2021, 11, 31),
+                organization,
+            }).create();
+
+            organization.periodId = period1.id;
+            await organization.save();
+
+            const period2 = await new RegistrationPeriodFactory({
+                startDate: new Date(2019, 0, 1),
+                endDate: new Date(2019, 11, 31),
+                organization,
+            }).create();
+
+            const createGroup = async (startDate: Date, endDate: Date, period: RegistrationPeriod) => {
+                const group = await new GroupFactory({ organization, period }).create();
+                group.settings.startDate = startDate;
+                group.settings.endDate = endDate;
+                await group.save();
+                return group;
+            };
+
+            // groups
+            const group1 = await createGroup(new Date(2021, 0, 1), new Date(2021, 11, 31), period1);
+            const group2 = await createGroup(new Date(2021, 0, 1), new Date(2021, 11, 31), period1);
+            const group3 = await createGroup(new Date(2019, 0, 1), new Date(2019, 11, 31), period2);
+
+            // document created in 2021
+            const document1 = await new DocumentTemplateFactory({
+                groups: [group1, group2, group3],
+                year: 0,
+            }).create();
+
+            document1.createdAt = new Date(2022, 0, 1);
+            await document1.save();
+
+            // document created in 2020
+            const document2 = await new DocumentTemplateFactory({
+                groups: [group1, group2, group3],
+                year: 0,
+            }).create();
+
+            document2.createdAt = new Date(2021, 0, 1);
+            await document2.save();
+
+            // document created in 2019
+            const document3 = await new DocumentTemplateFactory({
+                groups: [group1, group2, group3],
+                year: 0,
+            }).create();
+
+            document3.createdAt = new Date(2020, 0, 1);
+            await document3.save();
+
+            // act
+            await migrateDocumentYears();
+
+            // assert
+            const updatedDocument1 = await DocumentTemplate.getByID(document1.id);
+            const updatedDocument2 = await DocumentTemplate.getByID(document2.id);
+            const updatedDocument3 = await DocumentTemplate.getByID(document3.id);
+
+            // take most frequent year and prefer date of document creation
+            expect(updatedDocument1?.year).toBe(2021);
+            expect(updatedDocument2?.year).toBe(2021);
+            expect(updatedDocument3?.year).toBe(2021);
+        });
+
+        test('groups overlapping period', async () => {
+            const organization = await new OrganizationFactory({
+            }).create();
+
+            const period1 = await new RegistrationPeriodFactory({
+                startDate: new Date(2021, 0, 1),
+                endDate: new Date(2021, 11, 31),
+                organization,
+            }).create();
+
+            organization.periodId = period1.id;
+            await organization.save();
+
+            const period2 = await new RegistrationPeriodFactory({
+                startDate: new Date(2020, 0, 1),
+                endDate: new Date(2020, 11, 31),
+                organization,
+            }).create();
+
+            const period3 = await new RegistrationPeriodFactory({
+                startDate: new Date(2019, 0, 1),
+                endDate: new Date(2019, 11, 31),
+                organization,
+            }).create();
+
+            const createGroup = async (startDate: Date, endDate: Date, period: RegistrationPeriod) => {
+                const group = await new GroupFactory({ organization, period }).create();
+                group.settings.startDate = startDate;
+                group.settings.endDate = endDate;
+                await group.save();
+                return group;
+            };
+
+            // groups
+            const group1 = await createGroup(new Date(2020, 6, 1), new Date(2021, 5, 30), period1);
+            const group2 = await createGroup(new Date(2020, 7, 5), new Date(2021, 4, 3), period1);
+            const group3 = await createGroup(new Date(2018, 5, 1), new Date(2019, 10, 14), period3);
+
+            // document created in 2021
+            const document1 = await new DocumentTemplateFactory({
+                groups: [group1, group2, group3],
+                year: 0,
+            }).create();
+
+            document1.createdAt = new Date(2022, 0, 1);
+            await document1.save();
+
+            // document created in 2020
+            const document2 = await new DocumentTemplateFactory({
+                groups: [group1, group2, group3],
+                year: 0,
+            }).create();
+
+            document2.createdAt = new Date(2021, 0, 1);
+            await document2.save();
+
+            // document created in 2019
+            const document3 = await new DocumentTemplateFactory({
+                groups: [group1, group2, group3],
+                year: 0,
+            }).create();
+
+            document3.createdAt = new Date(2020, 0, 1);
+            await document3.save();
+
+            // act
+            await migrateDocumentYears();
+
+            // assert
+            const updatedDocument1 = await DocumentTemplate.getByID(document1.id);
+            const updatedDocument2 = await DocumentTemplate.getByID(document2.id);
+            const updatedDocument3 = await DocumentTemplate.getByID(document3.id);
+
+            // take most frequent year and prefer date of document creation
+            expect(updatedDocument1?.year).toBe(2021);
+            // should take 2020 because document was created in 2020
+            expect(updatedDocument2?.year).toBe(2020);
+            expect(updatedDocument3?.year).toBe(2021);
+        });
+    });
+
+    test('no groups should use year before creation', async () => {
+        // create document
+        const document = await new DocumentTemplateFactory({
+            groups: [],
+            year: 0,
+        }).create();
+
+        document.createdAt = new Date(2025, 0, 1);
+        await document.save();
+
+        // act
+        await migrateDocumentYears();
+
+        // assert
+        const updatedDocument = await DocumentTemplate.getByID(document.id);
+
+        // year should be year of creation
+        expect(updatedDocument?.year).toBe(2024);
+    });
+});

package/src/seeds/1765896674-document-update-year.ts

@@ -0,0 +1,75 @@
+import { Migration } from '@simonbackx/simple-database';
+import { DocumentTemplate, Group } from '@stamhoofd/models';
+import { SQL } from '@stamhoofd/sql';
+
+export async function migrateDocumentYears() {
+    let c = 0;
+    const totalDocuments = await DocumentTemplate.select().count();
+
+    for await (const document of DocumentTemplate.select().all()) {
+        c++;
+        if (c % 1000 === 0) {
+            console.log('Processed', c, 'of', totalDocuments);
+        }
+
+        // check
+        if (!document.year) {
+            // by default use the year before creation
+            let year: number = document.createdAt.getFullYear() - 1;
+
+            const groups = document.privateSettings.groups;
+            const groupIds: string[] = [...new Set(groups.map(g => g.group.id))];
+
+            if (groupIds.length > 0) {
+                const query = Group.select().where(SQL.where('id', groupIds));
+                const groupModels = await query.fetch();
+
+                // count the number of groups per year
+                const yearMap = new Map<number, number>();
+
+                for (const group of groupModels) {
+                    const startYear = group.settings.startDate.getFullYear();
+                    const endYear = group.settings.endDate.getFullYear();
+
+                    for (let y = startYear; y <= endYear; y++) {
+                        const count = yearMap.get(y) ?? 0;
+                        yearMap.set(y, count + 1);
+                    }
+                }
+
+                // find the year with the highest count
+                let topYear = 0;
+                let topCount = 0;
+                const yearBeforeCreation = document.createdAt.getFullYear() - 1;
+
+                for (const [year, count] of yearMap) {
+                    if (count > topCount
+                        // prefer the year before creation
+                        || (count === topCount && year === yearBeforeCreation)
+                        // next prefer the most recent year
+                        || (topYear !== yearBeforeCreation && year > topYear)
+                    ) {
+                        topYear = year;
+                        topCount = count;
+                    }
+                }
+
+                // use the year with the highest count
+                if (topCount > 0) {
+                    year = topYear;
+                }
+            }
+
+            document.year = year;
+            await document.save();
+        }
+    }
+};
+
+export default new Migration(async () => {
+    process.stdout.write('\n');
+    console.log('Start updating year of document templates.');
+    await migrateDocumentYears();
+
+    return Promise.resolve();
+});

package/src/seeds/1766150402-document-published-at.test.ts

@@ -0,0 +1,46 @@
+import { DocumentTemplate, DocumentTemplateFactory } from '@stamhoofd/models';
+import { SQL } from '@stamhoofd/sql';
+import { DocumentStatus } from '@stamhoofd/structures';
+import { initPublishedAtForPublishedDocuments } from './1766150402-document-published-at.js';
+
+describe('migration.document-published-at', () => {
+    it('should init published at for published documents', async () => {
+        // arrange
+        // published documents
+        const document1 = await createDocument(DocumentStatus.Published, new Date(2022, 0, 1));
+        const document2 = await createDocument(DocumentStatus.Published, new Date(2023, 5, 17));
+        const document3 = await createDocument(DocumentStatus.Published, new Date(2025, 3, 9));
+
+        // draft documents
+        const document4 = await createDocument(DocumentStatus.Draft, new Date(2022, 0, 1));
+        const document5 = await createDocument(DocumentStatus.Draft, new Date(2023, 5, 17));
+        const document6 = await createDocument(DocumentStatus.Draft, new Date(2025, 3, 9));
+
+        // reset published at (save does not update published at automatically)
+        await SQL.update(DocumentTemplate.table).set('publishedAt', null).where('id', [document1.id, document2.id, document3.id, document4.id, document5.id, document6.id]).update();
+
+        // act
+        await initPublishedAtForPublishedDocuments();
+
+        // assert
+        const updatedDocument1 = await DocumentTemplate.getByID(document1.id);
+        const updatedDocument2 = await DocumentTemplate.getByID(document2.id);
+        const updatedDocument3 = await DocumentTemplate.getByID(document3.id);
+
+        const updatedDocument4 = await DocumentTemplate.getByID(document4.id);
+        const updatedDocument5 = await DocumentTemplate.getByID(document5.id);
+        const updatedDocument6 = await DocumentTemplate.getByID(document6.id);
+
+        expect(updatedDocument1?.publishedAt?.getTime()).toEqual(document1.createdAt.getTime());
+        expect(updatedDocument2?.publishedAt?.getTime()).toEqual(document2.createdAt.getTime());
+        expect(updatedDocument3?.publishedAt?.getTime()).toEqual(document3.createdAt.getTime());
+
+        expect(updatedDocument4?.publishedAt).toBeNull();
+        expect(updatedDocument5?.publishedAt).toBeNull();
+        expect(updatedDocument6?.publishedAt).toBeNull();
+    });
+});
+
+async function createDocument(status: DocumentStatus, createdAt: Date) {
+    return await new DocumentTemplateFactory({ groups: [], status, createdAt }).create();
+};

package/src/seeds/1766150402-document-published-at.ts

@@ -0,0 +1,20 @@
+import { Migration } from '@simonbackx/simple-database';
+import { DocumentTemplate } from '@stamhoofd/models';
+import { SQL } from '@stamhoofd/sql';
+import { DocumentStatus } from '@stamhoofd/structures';
+
+export async function initPublishedAtForPublishedDocuments() {
+    await SQL.update(DocumentTemplate.table)
+        .set('publishedAt', SQL.column('createdAt'))
+        .where('publishedAt', null)
+        .where('status', DocumentStatus.Published)
+        .update();
+};
+
+export default new Migration(async () => {
+    process.stdout.write('\n');
+    console.log('Start init published at for published documents.');
+    await initPublishedAtForPublishedDocuments();
+
+    return Promise.resolve();
+});

package/src/services/PaymentService.ts

@@ -2,11 +2,11 @@ import createMollieClient, { PaymentStatus as MolliePaymentStatus } from '@molli
 import { BalanceItem, BalanceItemPayment, MolliePayment, MollieToken, Organization, PayconiqPayment, Payment } from '@stamhoofd/models';
 import { QueueHandler } from '@stamhoofd/queues';
 import { AuditLogSource, BalanceItemRelation, BalanceItemStatus, BalanceItemType, PaymentMethod, PaymentProvider, PaymentStatus } from '@stamhoofd/structures';
-import { BuckarooHelper } from '../helpers/BuckarooHelper';
-import { StripeHelper } from '../helpers/StripeHelper';
-import { AuditLogService } from './AuditLogService';
-import { BalanceItemPaymentService } from './BalanceItemPaymentService';
-import { BalanceItemService } from './BalanceItemService';
+import { BuckarooHelper } from '../helpers/BuckarooHelper.js';
+import { StripeHelper } from '../helpers/StripeHelper.js';
+import { AuditLogService } from './AuditLogService.js';
+import { BalanceItemPaymentService } from './BalanceItemPaymentService.js';
+import { BalanceItemService } from './BalanceItemService.js';
 
 export const PaymentService = {
     async handlePaymentStatusUpdate(payment: Payment, organization: Organization, status: PaymentStatus) {
@@ -336,46 +336,28 @@ export const PaymentService = {
      * Say the total amount to pay is 15,238 because (e.g. because of VAT). In that case,
      * we'll need to round the payment to 1 cent. That can cause issues in the financial statements because
      * the total amount of balances does not match the total amount received/paid.
-     * 
+     *
      * To fix that, we create an extra balance item with the difference. So the rounding always matches.
+     *
+     * TODO: update this method to generate a virtual invoice and use the price of the invoice instead of the rounded payment price, so we don't get differences in calculation
      */
     async round(payment: Payment) {
-        if (!payment.organizationId) {
-            throw new Error('Cannot round payments without organizationId')
-        }
-        
         const amount = payment.price;
-        const rounded = Payment.roundPrice(payment.price)
+        const rounded = Payment.roundPrice(payment.price);
         const difference = rounded - amount;
 
         if (difference === 0) {
             return;
         }
 
-        if (difference > 100) {
-            throw new Error('Unexpected rounding difference.')
+        if (difference > 100 || difference < -100) {
+            throw new Error('Unexpected rounding difference of ' + difference + ' for payment ' + payment.id);
         }
 
-        const balanceItem = new BalanceItem();
-        balanceItem.type = BalanceItemType.Rounding;
-        balanceItem.userId = payment.payingUserId;
-        balanceItem.payingOrganizationId = payment.payingOrganizationId
-        balanceItem.unitPrice = difference;
-        balanceItem.pricePaid = 0;
-        balanceItem.organizationId = payment.organizationId;
-        balanceItem.status = BalanceItemStatus.Hidden;
-        await balanceItem.save();
-
-        // Create balance item payment
-        const balanceItemPayment = new BalanceItemPayment();
-        balanceItemPayment.organizationId = payment.organizationId;
-        balanceItemPayment.balanceItemId = balanceItem.id;
-        balanceItemPayment.price = difference;
-        balanceItemPayment.paymentId = payment.id;
-        await balanceItemPayment.save();
+        // payment.roundingAmount = difference;
 
         // Change payment total price
-        payment.price += difference
+        payment.price += difference;
         await payment.save();
-    }
+    },
 };

package/src/sql-filters/base-registration-filter-compilers.ts

@@ -1,8 +1,10 @@
 import { SimpleError } from '@simonbackx/simple-errors';
-import { baseSQLFilterCompilers, createColumnFilter, createExistsFilter, SQL, SQLFilterDefinitions, SQLValueType } from '@stamhoofd/sql';
+import { baseSQLFilterCompilers, createColumnFilter, createExistsFilter, createJoinedRelationFilter, SQL, SQLFilterDefinitions, SQLIfNull, SQLValueType } from '@stamhoofd/sql';
 import { FilterWrapperMarker, PermissionLevel, StamhoofdFilter, unwrapFilter } from '@stamhoofd/structures';
-import { Context } from '../helpers/Context';
-import { organizationFilterCompilers } from './organizations';
+import { Context } from '../helpers/Context.js';
+import { memberCachedBalanceForOrganizationJoin, registrationCachedBalanceJoin } from '../helpers/outstandingBalanceJoin.js';
+import { SQLTranslatedString } from '../helpers/SQLTranslatedString.js';
+import { organizationFilterCompilers } from './organizations.js';
 
 async function checkGroupIdFilterAccess(filter: StamhoofdFilter, permissionLevel: PermissionLevel) {
     const groupIds = typeof filter === 'string'
@@ -77,6 +79,11 @@ export const baseRegistrationFilterCompilers: SQLFilterDefinitions = {
         type: SQLValueType.Number,
         nullable: false,
     }),
+    groupPrice: createColumnFilter({
+        expression: new SQLTranslatedString(SQL.column('groupPrice'), '$.value.name'),
+        type: SQLValueType.String,
+        nullable: true,
+    }),
     canRegister: createColumnFilter({
         expression: SQL.column('canRegister'),
         type: SQLValueType.Boolean,
@@ -110,6 +117,21 @@ export const baseRegistrationFilterCompilers: SQLFilterDefinitions = {
         type: SQLValueType.Datetime,
         nullable: true,
     }),
+    trialUntil: createColumnFilter({
+        expression: SQL.column('registrations', 'trialUntil'),
+        type: SQLValueType.Datetime,
+        nullable: true,
+    }),
+    startDate: createColumnFilter({
+        expression: SQL.column('registrations', 'startDate'),
+        type: SQLValueType.Datetime,
+        nullable: true,
+    }),
+    endDate: createColumnFilter({
+        expression: SQL.column('registrations', 'endDate'),
+        type: SQLValueType.Datetime,
+        nullable: true,
+    }),
     group: {
         ...baseSQLFilterCompilers,
         id: createColumnFilter({
@@ -126,7 +148,7 @@ export const baseRegistrationFilterCompilers: SQLFilterDefinitions = {
             nullable: false,
         }),
         name: createColumnFilter({
-            expression: SQL.jsonValue(SQL.column('groups', 'settings'), '$.value.name'),
+            expression: SQL.jsonExtract(SQL.column('groups', 'settings'), '$.value.name'),
             type: SQLValueType.JSONString,
             nullable: false,
         }),
@@ -150,4 +172,29 @@ export const baseRegistrationFilterCompilers: SQLFilterDefinitions = {
             ),
         organizationFilterCompilers,
     ),
+    memberCachedBalance: createJoinedRelationFilter(
+        memberCachedBalanceForOrganizationJoin,
+        {
+            amountOpen: createColumnFilter({
+                expression: new SQLIfNull(SQL.column('memberCachedBalance', 'amountOpen'), 0),
+                type: SQLValueType.Number,
+                nullable: false,
+            }),
+        },
+    ),
+    registrationCachedBalance: createJoinedRelationFilter(
+        registrationCachedBalanceJoin,
+        {
+            toPay: createColumnFilter({
+                expression: new SQLIfNull(SQL.column('registrationCachedBalance', 'toPay'), 0),
+                type: SQLValueType.Number,
+                nullable: false,
+            }),
+            price: createColumnFilter({
+                expression: new SQLIfNull(SQL.column('registrationCachedBalance', 'price'), 0),
+                type: SQLValueType.Number,
+                nullable: false,
+            }),
+        },
+    ),
 };

package/src/sql-filters/document-templates.ts

@@ -0,0 +1,45 @@
+import { baseSQLFilterCompilers, createColumnFilter, SQL, SQLFilterDefinitions, SQLValueType } from '@stamhoofd/sql';
+
+export const documentTemplateFilterCompilers: SQLFilterDefinitions = {
+    ...baseSQLFilterCompilers,
+    id: createColumnFilter({
+        expression: SQL.column('id'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    name: createColumnFilter({
+        expression: SQL.jsonExtract(SQL.column('settings'), '$.value.name'),
+        type: SQLValueType.JSONString,
+        nullable: false,
+    }),
+    year: createColumnFilter({
+        expression: SQL.column('year'),
+        type: SQLValueType.Number,
+        nullable: false,
+    }),
+    organizationId: createColumnFilter({
+        expression: SQL.column('organizationId'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    updatedAt: createColumnFilter({
+        expression: SQL.column('updatedAt'),
+        type: SQLValueType.Datetime,
+        nullable: false,
+    }),
+    createdAt: createColumnFilter({
+        expression: SQL.column('createdAt'),
+        type: SQLValueType.Datetime,
+        nullable: false,
+    }),
+    status: createColumnFilter({
+        expression: SQL.column('status'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    type: createColumnFilter({
+        expression: SQL.jsonExtract(SQL.column('privateSettings'), '$.value.templateDefinition.type'),
+        type: SQLValueType.JSONString,
+        nullable: false,
+    }),
+};

package/src/sql-filters/documents.ts

@@ -8,7 +8,7 @@ export const documentFilterCompilers: SQLFilterDefinitions = {
         nullable: false,
     }),
     description: createColumnFilter({
-        expression: SQL.jsonValue(SQL.column('data'), '$.value.description'),
+        expression: SQL.jsonExtract(SQL.column('data'), '$.value.description'),
         type: SQLValueType.JSONString,
         nullable: false,
     }),

package/src/sql-filters/events.ts

@@ -28,7 +28,7 @@ export const eventFilterCompilers: SQLFilterDefinitions = {
         nullable: false,
     }),
     'groupIds': createColumnFilter({
-        expression: SQL.jsonValue(SQL.column('meta'), '$.value.groups[*].id'),
+        expression: SQL.jsonExtract(SQL.column('meta'), '$.value.groups[*].id'),
         type: SQLValueType.JSONArray,
         nullable: true,
     }),
@@ -43,27 +43,27 @@ export const eventFilterCompilers: SQLFilterDefinitions = {
         nullable: false,
     }),
     'defaultAgeGroupIds': createColumnFilter({
-        expression: SQL.jsonValue(SQL.column('meta'), '$.value.defaultAgeGroupIds'),
+        expression: SQL.jsonExtract(SQL.column('meta'), '$.value.defaultAgeGroupIds'),
         type: SQLValueType.JSONArray,
         nullable: true,
     }),
     'organizationTagIds': createColumnFilter({
-        expression: SQL.jsonValue(SQL.column('meta'), '$.value.organizationTagIds'),
+        expression: SQL.jsonExtract(SQL.column('meta'), '$.value.organizationTagIds'),
         type: SQLValueType.JSONArray,
         nullable: true,
     }),
     'minAge': createColumnFilter({
-        expression: SQL.jsonValue(SQL.column('meta'), '$.value.minAge'),
+        expression: SQL.jsonExtract(SQL.column('meta'), '$.value.minAge'),
         type: SQLValueType.JSONNumber,
         nullable: true,
     }),
     'maxAge': createColumnFilter({
-        expression: SQL.jsonValue(SQL.column('meta'), '$.value.maxAge'),
+        expression: SQL.jsonExtract(SQL.column('meta'), '$.value.maxAge'),
         type: SQLValueType.JSONNumber,
         nullable: true,
     }),
     'meta.visible': createColumnFilter({
-        expression: SQL.jsonValue(SQL.column('meta'), '$.value.visible'),
+        expression: SQL.jsonExtract(SQL.column('meta'), '$.value.visible'),
         type: SQLValueType.JSONBoolean,
         nullable: false,
     }),