@stamhoofd/backend 2.107.3 → 2.109.0

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,
     }),

package/src/sql-filters/groups.ts

@@ -1,4 +1,5 @@
-import { baseSQLFilterCompilers, createColumnFilter, createWildcardColumnFilter, SQL, SQLJsonExtract, SQLFilterDefinitions, SQLValueType } from '@stamhoofd/sql';
+import { baseSQLFilterCompilers, createColumnFilter, createWildcardColumnFilter, SQL, SQLFilterDefinitions, SQLJsonExtract, SQLValueType } from '@stamhoofd/sql';
+import { SQLTranslatedString } from '../helpers/SQLTranslatedString.js';
 
 export const groupFilterCompilers: SQLFilterDefinitions = {
     ...baseSQLFilterCompilers,
@@ -18,9 +19,9 @@ export const groupFilterCompilers: SQLFilterDefinitions = {
         nullable: false,
     }),
     name: createColumnFilter({
-        expression: SQL.jsonValue(SQL.column('settings'), '$.value.name'),
-        type: SQLValueType.JSONString,
-        nullable: false,
+        expression: new SQLTranslatedString(SQL.column('settings'), '$.value.name'),
+        type: SQLValueType.String,
+        nullable: true,
     }),
     status: createColumnFilter({
         expression: SQL.column('status'),
@@ -34,14 +35,14 @@ export const groupFilterCompilers: SQLFilterDefinitions = {
     }),
     bundleDiscounts: createWildcardColumnFilter(
         (key: string) => ({
-            expression: SQL.jsonValue(SQL.column('settings'), `$.value.prices[*].bundleDiscounts.${SQLJsonExtract.escapePathComponent(key)}`, true),
+            expression: SQL.jsonExtract(SQL.column('settings'), `$.value.prices[*].bundleDiscounts.${SQLJsonExtract.escapePathComponent(key)}`, true),
             type: SQLValueType.JSONArray,
             nullable: true,
         }),
         (key: string) => ({
             ...baseSQLFilterCompilers,
             name: createColumnFilter({
-                expression: SQL.jsonValue(SQL.column('settings'), `$.value.prices[*].bundleDiscounts.${SQLJsonExtract.escapePathComponent(key)}.name`, true),
+                expression: SQL.jsonExtract(SQL.column('settings'), `$.value.prices[*].bundleDiscounts.${SQLJsonExtract.escapePathComponent(key)}.name`, true),
                 type: SQLValueType.JSONArray,
                 nullable: true,
             }),

package/src/sql-filters/members.ts

@@ -1,10 +1,10 @@
 import { SimpleError } from '@simonbackx/simple-errors';
 import { Email, Member } from '@stamhoofd/models';
-import { baseSQLFilterCompilers, createColumnFilter, createExistsFilter, SQL, SQLAge, SQLCast, SQLConcat, SQLFilterDefinitions, SQLValueType, SQLScalar, createWildcardColumnFilter, SQLJsonExtract } from '@stamhoofd/sql';
+import { baseSQLFilterCompilers, createColumnFilter, createExistsFilter, createWildcardColumnFilter, SQL, SQLAge, SQLCast, SQLConcat, SQLFilterDefinitions, SQLJsonExtract, SQLScalar, SQLValueType } from '@stamhoofd/sql';
 import { AccessRight } from '@stamhoofd/structures';
-import { Context } from '../helpers/Context';
-import { baseRegistrationFilterCompilers } from './base-registration-filter-compilers';
-import { organizationFilterCompilers } from './organizations';
+import { Context } from '../helpers/Context.js';
+import { baseRegistrationFilterCompilers } from './base-registration-filter-compilers.js';
+import { organizationFilterCompilers } from './organizations.js';
 
 const membersTable = SQL.table(Member.table);
 
@@ -20,7 +20,7 @@ export const memberFilterCompilers: SQLFilterDefinitions = {
     }),
     'memberNumber': createColumnFilter({
         expression: SQL.column(membersTable, 'memberNumber'),
-        type: SQLValueType.Number,
+        type: SQLValueType.String,
         nullable: true,
     }),
     'firstName': createColumnFilter({
@@ -48,7 +48,7 @@ export const memberFilterCompilers: SQLFilterDefinitions = {
         nullable: true,
     }),
     'gender': createColumnFilter({
-        expression: SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.gender'),
+        expression: SQL.jsonExtract(SQL.column(membersTable, 'details'), '$.value.gender'),
         type: SQLValueType.JSONString,
         nullable: false,
     }),
@@ -58,13 +58,18 @@ export const memberFilterCompilers: SQLFilterDefinitions = {
         type: SQLValueType.Datetime,
         nullable: true,
     }),
+    'createdAt': createColumnFilter({
+        expression: SQL.column(membersTable, 'createdAt'),
+        type: SQLValueType.Datetime,
+        nullable: false,
+    }),
     'organizationName': createColumnFilter({
         expression: SQL.column('organizations', 'name'),
         type: SQLValueType.String,
         nullable: false,
     }),
     'details.requiresFinancialSupport': createColumnFilter({
-        expression: SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.requiresFinancialSupport.value'),
+        expression: SQL.jsonExtract(SQL.column(membersTable, 'details'), '$.value.requiresFinancialSupport.value'),
         type: SQLValueType.JSONBoolean,
         nullable: true,
         checkPermission: async () => {
@@ -94,12 +99,12 @@ export const memberFilterCompilers: SQLFilterDefinitions = {
         },
     }),
     'email': createColumnFilter({
-        expression: SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.email'),
+        expression: SQL.jsonExtract(SQL.column(membersTable, 'details'), '$.value.email'),
         type: SQLValueType.JSONString,
         nullable: true,
     }),
     'parentEmail': createColumnFilter({
-        expression: SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.parents[*].email'),
+        expression: SQL.jsonExtract(SQL.column(membersTable, 'details'), '$.value.parents[*].email'),
         type: SQLValueType.JSONArray,
         nullable: true,
     }),
@@ -132,34 +137,34 @@ export const memberFilterCompilers: SQLFilterDefinitions = {
         }),
     },
     'unverifiedEmail': createColumnFilter({
-        expression: SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.unverifiedEmails'),
+        expression: SQL.jsonExtract(SQL.column(membersTable, 'details'), '$.value.unverifiedEmails'),
         type: SQLValueType.JSONArray,
         nullable: true,
     }),
     'phone': createColumnFilter({
-        expression: SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.phone'),
+        expression: SQL.jsonExtract(SQL.column(membersTable, 'details'), '$.value.phone'),
         type: SQLValueType.JSONString,
         nullable: true,
     }),
     'details.address': {
         ...baseSQLFilterCompilers,
         city: createColumnFilter({
-            expression: SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.address.city'),
+            expression: SQL.jsonExtract(SQL.column(membersTable, 'details'), '$.value.address.city'),
             type: SQLValueType.JSONString,
             nullable: true,
         }),
         postalCode: createColumnFilter({
-            expression: SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.address.postalCode'),
+            expression: SQL.jsonExtract(SQL.column(membersTable, 'details'), '$.value.address.postalCode'),
             type: SQLValueType.JSONString,
             nullable: true,
         }),
         street: createColumnFilter({
-            expression: SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.address.street'),
+            expression: SQL.jsonExtract(SQL.column(membersTable, 'details'), '$.value.address.street'),
             type: SQLValueType.JSONString,
             nullable: true,
         }),
         number: createColumnFilter({
-            expression: SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.address.number'),
+            expression: SQL.jsonExtract(SQL.column(membersTable, 'details'), '$.value.address.number'),
             type: SQLValueType.JSONString,
             nullable: true,
         }),
@@ -167,33 +172,33 @@ export const memberFilterCompilers: SQLFilterDefinitions = {
     'details.parents[*].address': {
         ...baseSQLFilterCompilers,
         city: createColumnFilter({
-            expression: SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.parents[*].address.city'),
+            expression: SQL.jsonExtract(SQL.column(membersTable, 'details'), '$.value.parents[*].address.city'),
             type: SQLValueType.JSONArray,
             nullable: true,
         }),
         postalCode: createColumnFilter({
-            expression: SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.parents[*].address.postalCode'),
+            expression: SQL.jsonExtract(SQL.column(membersTable, 'details'), '$.value.parents[*].address.postalCode'),
             type: SQLValueType.JSONArray,
             nullable: true,
         }),
         street: createColumnFilter({
-            expression: SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.parents[*].address.street'),
+            expression: SQL.jsonExtract(SQL.column(membersTable, 'details'), '$.value.parents[*].address.street'),
             type: SQLValueType.JSONArray,
             nullable: true,
         }),
         number: createColumnFilter({
-            expression: SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.parents[*].address.number'),
+            expression: SQL.jsonExtract(SQL.column(membersTable, 'details'), '$.value.parents[*].address.number'),
             type: SQLValueType.JSONArray,
             nullable: true,
         }),
     },
     'parentPhone': createColumnFilter({
-        expression: SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.parents[*].phone'),
+        expression: SQL.jsonExtract(SQL.column(membersTable, 'details'), '$.value.parents[*].phone'),
         type: SQLValueType.JSONArray,
         nullable: true,
     }),
     'unverifiedPhone': createColumnFilter({
-        expression: SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.unverifiedPhones'),
+        expression: SQL.jsonExtract(SQL.column(membersTable, 'details'), '$.value.unverifiedPhones'),
         type: SQLValueType.JSONArray,
         nullable: true,
     }),
@@ -458,21 +463,21 @@ export const memberFilterCompilers: SQLFilterDefinitions = {
         ...baseSQLFilterCompilers,
         recordAnswers: createWildcardColumnFilter(
             (key: string) => ({
-                expression: SQL.jsonValue(SQL.column('details'), `$.value.recordAnswers.${SQLJsonExtract.escapePathComponent(key)}`, true),
+                expression: SQL.jsonExtract(SQL.column('details'), `$.value.recordAnswers.${SQLJsonExtract.escapePathComponent(key)}`, true),
                 type: SQLValueType.JSONObject,
                 nullable: true,
             }),
             (key: string) => ({
                 ...baseSQLFilterCompilers,
                 selected: createColumnFilter({
-                    expression: SQL.jsonValue(SQL.column('details'), `$.value.recordAnswers.${SQLJsonExtract.escapePathComponent(key)}.selected`, true),
+                    expression: SQL.jsonExtract(SQL.column('details'), `$.value.recordAnswers.${SQLJsonExtract.escapePathComponent(key)}.selected`, true),
                     type: SQLValueType.JSONBoolean,
                     nullable: true,
                 }),
                 selectedChoice: {
                     ...baseSQLFilterCompilers,
                     id: createColumnFilter({
-                        expression: SQL.jsonValue(SQL.column('details'), `$.value.recordAnswers.${SQLJsonExtract.escapePathComponent(key)}.selectedChoice.id`, true),
+                        expression: SQL.jsonExtract(SQL.column('details'), `$.value.recordAnswers.${SQLJsonExtract.escapePathComponent(key)}.selectedChoice.id`, true),
                         type: SQLValueType.JSONString,
                         nullable: true,
                     }),
@@ -480,13 +485,13 @@ export const memberFilterCompilers: SQLFilterDefinitions = {
                 selectedChoices: {
                     ...baseSQLFilterCompilers,
                     id: createColumnFilter({
-                        expression: SQL.jsonValue(SQL.column('details'), `$.value.recordAnswers.${SQLJsonExtract.escapePathComponent(key)}.selectedChoices[*].id`, true),
+                        expression: SQL.jsonExtract(SQL.column('details'), `$.value.recordAnswers.${SQLJsonExtract.escapePathComponent(key)}.selectedChoices[*].id`, true),
                         type: SQLValueType.JSONArray,
                         nullable: true,
                     }),
                 },
                 value: createColumnFilter({
-                    expression: SQL.jsonValue(SQL.column('details'), `$.value.recordAnswers.${SQLJsonExtract.escapePathComponent(key)}.value`, true),
+                    expression: SQL.jsonExtract(SQL.column('details'), `$.value.recordAnswers.${SQLJsonExtract.escapePathComponent(key)}.value`, true),
                     type: SQLValueType.JSONString,
                     nullable: true,
                 }),