@stamhoofd/backend 2.107.3 → 2.109.0

package/src/sql-filters/orders.ts

@@ -1,4 +1,4 @@
-import { baseSQLFilterCompilers, createColumnFilter, SQL, SQLCast, SQLConcat, SQLJsonUnquote, SQLFilterDefinitions, SQLValueType, SQLScalar, createExistsFilter, createWildcardColumnFilter, SQLJsonExtract } from '@stamhoofd/sql';
+import { baseSQLFilterCompilers, createColumnFilter, createExistsFilter, createWildcardColumnFilter, SQL, SQLCast, SQLConcat, SQLFilterDefinitions, SQLJsonExtract, SQLJsonUnquote, SQLScalar, SQLValueType } from '@stamhoofd/sql';
 
 export const orderFilterCompilers: SQLFilterDefinitions = {
     ...baseSQLFilterCompilers,
@@ -26,12 +26,12 @@ export const orderFilterCompilers: SQLFilterDefinitions = {
         nullable: false,
     }),
     timeSlotEndTime: createColumnFilter({
-        expression: SQL.jsonValue(SQL.column('data'), '$.value.timeSlot.endTime'),
+        expression: SQL.jsonExtract(SQL.column('data'), '$.value.timeSlot.endTime'),
         type: SQLValueType.JSONString,
         nullable: true,
     }),
     timeSlotStartTime: createColumnFilter({
-        expression: SQL.jsonValue(SQL.column('data'), '$.value.timeSlot.startTime'),
+        expression: SQL.jsonExtract(SQL.column('data'), '$.value.timeSlot.startTime'),
         type: SQLValueType.JSONString,
         nullable: true,
     }),
@@ -51,17 +51,17 @@ export const orderFilterCompilers: SQLFilterDefinitions = {
         nullable: false,
     }),
     paymentMethod: createColumnFilter({
-        expression: SQL.jsonValue(SQL.column('data'), '$.value.paymentMethod'),
+        expression: SQL.jsonExtract(SQL.column('data'), '$.value.paymentMethod'),
         type: SQLValueType.JSONString,
         nullable: false,
     }),
     checkoutMethod: createColumnFilter({
-        expression: SQL.jsonValue(SQL.column('data'), '$.value.checkoutMethod.type'),
+        expression: SQL.jsonExtract(SQL.column('data'), '$.value.checkoutMethod.type'),
         type: SQLValueType.JSONString,
         nullable: true,
     }),
     timeSlotDate: createColumnFilter({
-        expression: SQL.jsonValue(SQL.column('data'), '$.value.timeSlot.date'),
+        expression: SQL.jsonExtract(SQL.column('data'), '$.value.timeSlot.date'),
         type: SQLValueType.JSONString,
         nullable: true,
     }),
@@ -73,21 +73,21 @@ export const orderFilterCompilers: SQLFilterDefinitions = {
     name: createColumnFilter({
         expression: new SQLCast(
             new SQLConcat(
-                new SQLJsonUnquote(SQL.jsonValue(SQL.column('data'), '$.value.customer.firstName')),
+                new SQLJsonUnquote(SQL.jsonExtract(SQL.column('data'), '$.value.customer.firstName')),
                 new SQLScalar(' '),
-                new SQLJsonUnquote(SQL.jsonValue(SQL.column('data'), '$.value.customer.lastName')),
+                new SQLJsonUnquote(SQL.jsonExtract(SQL.column('data'), '$.value.customer.lastName')),
             ),
             'CHAR'),
         type: SQLValueType.String,
         nullable: false,
     }),
     email: createColumnFilter({
-        expression: SQL.jsonValue(SQL.column('data'), '$.value.customer.email'),
+        expression: SQL.jsonExtract(SQL.column('data'), '$.value.customer.email'),
         type: SQLValueType.JSONString,
         nullable: false,
     }),
     phone: createColumnFilter({
-        expression: SQL.jsonValue(SQL.column('data'), '$.value.customer.phone'),
+        expression: SQL.jsonExtract(SQL.column('data'), '$.value.customer.phone'),
         type: SQLValueType.JSONString,
         nullable: false,
     }),
@@ -119,7 +119,7 @@ export const orderFilterCompilers: SQLFilterDefinitions = {
             .join(
                 SQL.join(
                     SQL.jsonTable(
-                        SQL.jsonValue(SQL.column('innerOrders', 'data'), '$.value.cart.items'),
+                        SQL.jsonExtract(SQL.column('innerOrders', 'data'), '$.value.cart.items'),
                         'items',
                     )
                         .addColumn(
@@ -168,21 +168,21 @@ export const orderFilterCompilers: SQLFilterDefinitions = {
 
     recordAnswers: createWildcardColumnFilter(
         (key: string) => ({
-            expression: SQL.jsonValue(SQL.column('data'), `$.value.recordAnswers.${SQLJsonExtract.escapePathComponent(key)}`, true),
+            expression: SQL.jsonExtract(SQL.column('data'), `$.value.recordAnswers.${SQLJsonExtract.escapePathComponent(key)}`, true),
             type: SQLValueType.JSONObject,
             nullable: true,
         }),
         (key: string) => ({
             ...baseSQLFilterCompilers,
             selected: createColumnFilter({
-                expression: SQL.jsonValue(SQL.column('data'), `$.value.recordAnswers.${SQLJsonExtract.escapePathComponent(key)}.selected`, true),
+                expression: SQL.jsonExtract(SQL.column('data'), `$.value.recordAnswers.${SQLJsonExtract.escapePathComponent(key)}.selected`, true),
                 type: SQLValueType.JSONBoolean,
                 nullable: true,
             }),
             selectedChoice: {
                 ...baseSQLFilterCompilers,
                 id: createColumnFilter({
-                    expression: SQL.jsonValue(SQL.column('data'), `$.value.recordAnswers.${SQLJsonExtract.escapePathComponent(key)}.selectedChoice.id`, true),
+                    expression: SQL.jsonExtract(SQL.column('data'), `$.value.recordAnswers.${SQLJsonExtract.escapePathComponent(key)}.selectedChoice.id`, true),
                     type: SQLValueType.JSONString,
                     nullable: true,
                 }),
@@ -190,13 +190,13 @@ export const orderFilterCompilers: SQLFilterDefinitions = {
             selectedChoices: {
                 ...baseSQLFilterCompilers,
                 id: createColumnFilter({
-                    expression: SQL.jsonValue(SQL.column('data'), `$.value.recordAnswers.${SQLJsonExtract.escapePathComponent(key)}.selectedChoices[*].id`, true),
+                    expression: SQL.jsonExtract(SQL.column('data'), `$.value.recordAnswers.${SQLJsonExtract.escapePathComponent(key)}.selectedChoices[*].id`, true),
                     type: SQLValueType.JSONArray,
                     nullable: true,
                 }),
             },
             value: createColumnFilter({
-                expression: SQL.jsonValue(SQL.column('data'), `$.value.recordAnswers.${SQLJsonExtract.escapePathComponent(key)}.value`, true),
+                expression: SQL.jsonExtract(SQL.column('data'), `$.value.recordAnswers.${SQLJsonExtract.escapePathComponent(key)}.value`, true),
                 type: SQLValueType.JSONString,
                 nullable: true,
             }),

package/src/sql-filters/organizations.ts

@@ -1,4 +1,4 @@
-import { baseSQLFilterCompilers, createColumnFilter, createExistsFilter, SQL, SQLConcat, SQLFilterDefinitions, SQLValueType, SQLNow, SQLNull, SQLScalar, SQLWhereEqual, SQLWhereOr, SQLWhereSign } from '@stamhoofd/sql';
+import { baseSQLFilterCompilers, createColumnFilter, createExistsFilter, SQL, SQLConcat, SQLFilterDefinitions, SQLNow, SQLNull, SQLScalar, SQLValueType, SQLWhereEqual, SQLWhereOr, SQLWhereSign } from '@stamhoofd/sql';
 import { SetupStepType } from '@stamhoofd/structures';
 
 export const organizationFilterCompilers: SQLFilterDefinitions = {
@@ -29,32 +29,32 @@ export const organizationFilterCompilers: SQLFilterDefinitions = {
         nullable: false,
     }),
     city: createColumnFilter({
-        expression: SQL.jsonValue(SQL.column('organizations', 'address'), '$.value.city'),
+        expression: SQL.jsonExtract(SQL.column('organizations', 'address'), '$.value.city'),
         type: SQLValueType.JSONString,
         nullable: false,
     }),
     postalCode: createColumnFilter({
-        expression: SQL.jsonValue(SQL.column('organizations', 'address'), '$.value.postalCode'),
+        expression: SQL.jsonExtract(SQL.column('organizations', 'address'), '$.value.postalCode'),
         type: SQLValueType.JSONString,
         nullable: false,
     }),
     country: createColumnFilter({
-        expression: SQL.jsonValue(SQL.column('organizations', 'address'), '$.value.country'),
+        expression: SQL.jsonExtract(SQL.column('organizations', 'address'), '$.value.country'),
         type: SQLValueType.JSONString,
         nullable: false,
     }),
     umbrellaOrganization: createColumnFilter({
-        expression: SQL.jsonValue(SQL.column('organizations', 'meta'), '$.value.umbrellaOrganization'),
+        expression: SQL.jsonExtract(SQL.column('organizations', 'meta'), '$.value.umbrellaOrganization'),
         type: SQLValueType.JSONString,
         nullable: true,
     }),
     type: createColumnFilter({
-        expression: SQL.jsonValue(SQL.column('organizations', 'meta'), '$.value.type'),
+        expression: SQL.jsonExtract(SQL.column('organizations', 'meta'), '$.value.type'),
         type: SQLValueType.JSONString,
         nullable: false,
     }),
     tags: createColumnFilter({
-        expression: SQL.jsonValue(SQL.column('organizations', 'meta'), '$.value.tags'),
+        expression: SQL.jsonExtract(SQL.column('organizations', 'meta'), '$.value.tags'),
         type: SQLValueType.JSONArray,
         nullable: false,
     }),
@@ -80,7 +80,7 @@ export const organizationFilterCompilers: SQLFilterDefinitions = {
                             {
                                 ...baseSQLFilterCompilers,
                                 reviewedAt: createColumnFilter({
-                                    expression: SQL.jsonValue(
+                                    expression: SQL.jsonExtract(
                                         SQL.column('organization_registration_periods', 'setupSteps'),
                                         `$.value.steps.${setupStep}.review.date`,
                                     ),
@@ -140,7 +140,7 @@ export const organizationFilterCompilers: SQLFilterDefinitions = {
         {
             ...baseSQLFilterCompilers,
             type: createColumnFilter({
-                expression: SQL.jsonValue(SQL.column('meta'), '$.value.type'),
+                expression: SQL.jsonExtract(SQL.column('meta'), '$.value.type'),
                 type: SQLValueType.JSONString,
                 nullable: false,
             }),
@@ -181,7 +181,7 @@ export const organizationFilterCompilers: SQLFilterDefinitions = {
                 nullable: false,
             }),
             email: createColumnFilter({
-                expression: SQL.jsonValue(SQL.column('details'), '$.value.email'),
+                expression: SQL.jsonExtract(SQL.column('details'), '$.value.email'),
                 type: SQLValueType.JSONString,
                 nullable: true,
             }),
@@ -199,7 +199,7 @@ export const organizationFilterCompilers: SQLFilterDefinitions = {
             .join(
                 SQL.join(
                     SQL.jsonTable(
-                        SQL.jsonValue(SQL.column('innerOrganizations', 'meta'), '$.value.companies'),
+                        SQL.jsonExtract(SQL.column('innerOrganizations', 'meta'), '$.value.companies'),
                         'companies',
                     )
                         .addColumn(

package/src/sql-filters/payments.ts

@@ -1,4 +1,4 @@
-import { baseSQLFilterCompilers, createColumnFilter, createExistsFilter, SQL, SQLCast, SQLConcat, SQLJsonUnquote, SQLFilterDefinitions, SQLValueType, SQLScalar } from '@stamhoofd/sql';
+import { baseSQLFilterCompilers, createColumnFilter, createExistsFilter, SQL, SQLCast, SQLConcat, SQLFilterDefinitions, SQLJsonUnquote, SQLScalar, SQLValueType } from '@stamhoofd/sql';
 import { balanceItemPaymentsCompilers } from './balance-item-payments';
 
 /**
@@ -59,26 +59,26 @@ export const paymentFilterCompilers: SQLFilterDefinitions = {
     customer: {
         ...baseSQLFilterCompilers,
         email: createColumnFilter({
-            expression: SQL.jsonValue(SQL.column('customer'), '$.value.email'),
+            expression: SQL.jsonExtract(SQL.column('customer'), '$.value.email'),
             type: SQLValueType.JSONString,
             nullable: true,
         }),
         firstName: createColumnFilter({
-            expression: SQL.jsonValue(SQL.column('customer'), '$.value.firstName'),
+            expression: SQL.jsonExtract(SQL.column('customer'), '$.value.firstName'),
             type: SQLValueType.JSONString,
             nullable: true,
         }),
         lastName: createColumnFilter({
-            expression: SQL.jsonValue(SQL.column('customer'), '$.value.lastName'),
+            expression: SQL.jsonExtract(SQL.column('customer'), '$.value.lastName'),
             type: SQLValueType.JSONString,
             nullable: true,
         }),
         name: createColumnFilter({
             expression: new SQLCast(
                 new SQLConcat(
-                    new SQLJsonUnquote(SQL.jsonValue(SQL.column('customer'), '$.value.firstName')),
+                    new SQLJsonUnquote(SQL.jsonExtract(SQL.column('customer'), '$.value.firstName')),
                     new SQLScalar(' '),
-                    new SQLJsonUnquote(SQL.jsonValue(SQL.column('customer'), '$.value.lastName')),
+                    new SQLJsonUnquote(SQL.jsonExtract(SQL.column('customer'), '$.value.lastName')),
                 ),
                 'CHAR',
             ),
@@ -88,22 +88,22 @@ export const paymentFilterCompilers: SQLFilterDefinitions = {
         company: {
             ...baseSQLFilterCompilers,
             name: createColumnFilter({
-                expression: SQL.jsonValue(SQL.column('customer'), '$.value.company.name'),
+                expression: SQL.jsonExtract(SQL.column('customer'), '$.value.company.name'),
                 type: SQLValueType.JSONString,
                 nullable: true,
             }),
             VATNumber: createColumnFilter({
-                expression: SQL.jsonValue(SQL.column('customer'), '$.value.company.VATNumber'),
+                expression: SQL.jsonExtract(SQL.column('customer'), '$.value.company.VATNumber'),
                 type: SQLValueType.JSONString,
                 nullable: true,
             }),
             companyNumber: createColumnFilter({
-                expression: SQL.jsonValue(SQL.column('customer'), '$.value.company.companyNumber'),
+                expression: SQL.jsonExtract(SQL.column('customer'), '$.value.company.companyNumber'),
                 type: SQLValueType.JSONString,
                 nullable: true,
             }),
             administrationEmail: createColumnFilter({
-                expression: SQL.jsonValue(SQL.column('customer'), '$.value.company.administrationEmail'),
+                expression: SQL.jsonExtract(SQL.column('customer'), '$.value.company.administrationEmail'),
                 type: SQLValueType.JSONString,
                 nullable: true,
             }),

package/src/sql-filters/registrations.ts

@@ -1,12 +1,16 @@
-import { Group, Member, Registration } from '@stamhoofd/models';
+import { Group, Member, Organization, Registration } from '@stamhoofd/models';
 import { baseSQLFilterCompilers, createColumnFilter, createJoinedRelationFilter, SQL, SQLFilterDefinitions, SQLValueType } from '@stamhoofd/sql';
-import { baseRegistrationFilterCompilers } from './base-registration-filter-compilers';
-import { memberFilterCompilers } from './members';
+import { SQLTranslatedString } from '../helpers/SQLTranslatedString.js';
+import { baseRegistrationFilterCompilers } from './base-registration-filter-compilers.js';
+import { memberFilterCompilers } from './members.js';
+import { organizationFilterCompilers } from './organizations.js';
 
 export const memberJoin = SQL.join(Member.table).where(SQL.column(Member.table, 'id'), SQL.column(Registration.table, 'memberId'));
 
 export const groupJoin = SQL.join(Group.table).where(SQL.column(Group.table, 'id'), SQL.column(Registration.table, 'groupId'));
 
+export const organizationJoin = SQL.join(Organization.table).where(SQL.column(Organization.table, 'id'), SQL.column(Registration.table, 'organizationId'));
+
 export const registrationFilterCompilers: SQLFilterDefinitions = {
     ...baseSQLFilterCompilers,
     ...baseRegistrationFilterCompilers,
@@ -29,9 +33,9 @@ export const registrationFilterCompilers: SQLFilterDefinitions = {
                 nullable: false,
             }),
             name: createColumnFilter({
-                expression: SQL.jsonValue(SQL.column('groups', 'settings'), '$.value.name'),
-                type: SQLValueType.JSONString,
-                nullable: false,
+                expression: new SQLTranslatedString(SQL.column('groups', 'settings'), '$.value.name'),
+                type: SQLValueType.String,
+                nullable: true,
             }),
             status: createColumnFilter({
                 expression: SQL.column('groups', 'status'),
@@ -50,4 +54,8 @@ export const registrationFilterCompilers: SQLFilterDefinitions = {
             }),
         },
     ),
+    organization: createJoinedRelationFilter(
+        organizationJoin,
+        organizationFilterCompilers,
+    ),
 };

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

@@ -0,0 +1,79 @@
+import { DocumentTemplate } from '@stamhoofd/models';
+import { SQL, SQLOrderBy, SQLOrderByDirection, SQLSortDefinitions } from '@stamhoofd/sql';
+import { Formatter } from '@stamhoofd/utility';
+
+export const documentTemplateSorters: SQLSortDefinitions<DocumentTemplate> = {
+    // WARNING! TEST NEW SORTERS THOROUGHLY!
+    // Try to avoid creating sorters on fields that er not 1:1 with the database, that often causes pagination issues if not thought through
+    // An example: sorting on 'name' is not a good idea, because it is a concatenation of two fields.
+    // You might be tempted to use ORDER BY firstName, lastName, but that will not work as expected and it needs to be ORDER BY CONCAT(firstName, ' ', lastName)
+    // Why? Because ORDER BY firstName, lastName produces a different order dan ORDER BY CONCAT(firstName, ' ', lastName) if there are multiple people with spaces in the first name
+    // And that again causes issues with pagination because the next query will append a filter of name > 'John Doe' - causing duplicate and/or skipped results
+    // What if you need mapping? simply map the sorters in the frontend: name -> firstname, lastname, age -> birthDay, etc.
+    id: {
+        getValue(a) {
+            return a.id;
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('id'),
+                direction,
+            });
+        },
+    },
+    name: {
+        getValue(a) {
+            return a.settings.name;
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.jsonExtract(SQL.column('settings'), '$.value.name'),
+                direction,
+            });
+        },
+    },
+    year: {
+        getValue(a) {
+            return a.year;
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('year'),
+                direction,
+            });
+        },
+    },
+    updatedAt: {
+        getValue(a) {
+            return Formatter.dateTimeIso(a.updatedAt);
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('updatedAt'),
+                direction,
+            });
+        },
+    },
+    createdAt: {
+        getValue(a) {
+            return Formatter.dateTimeIso(a.createdAt);
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('createdAt'),
+                direction,
+            });
+        },
+    },
+    status: {
+        getValue(a) {
+            return a.status;
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('status'),
+                direction,
+            });
+        },
+    },
+};

package/src/sql-sorters/documents.ts

@@ -27,7 +27,7 @@ export const documentSorters: SQLSortDefinitions<Document> = {
         },
         toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
             return new SQLOrderBy({
-                column: SQL.jsonValue(SQL.column('data'), '$.value.description'),
+                column: SQL.jsonExtract(SQL.column('data'), '$.value.description'),
                 direction,
             });
         },

package/src/sql-sorters/members.ts

@@ -22,6 +22,17 @@ export const memberSorters: SQLSortDefinitions<MemberWithRegistrations> = {
             });
         },
     },
+    memberNumber: {
+        getValue(a) {
+            return a.memberNumber;
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('memberNumber'),
+                direction,
+            });
+        },
+    },
     firstName: {
         getValue(a) {
             return a.firstName;
@@ -55,4 +66,15 @@ export const memberSorters: SQLSortDefinitions<MemberWithRegistrations> = {
             });
         },
     },
+    createdAt: {
+        getValue(a) {
+            return a.createdAt;
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('createdAt'),
+                direction,
+            });
+        },
+    },
 };

package/src/sql-sorters/orders.ts

@@ -71,7 +71,7 @@ export const orderSorters: SQLSortDefinitions<Order> = {
         },
         toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
             return new SQLOrderBy({
-                column: SQL.jsonValue(SQL.column('data'), '$.value.paymentMethod'),
+                column: SQL.jsonExtract(SQL.column('data'), '$.value.paymentMethod'),
                 direction,
             });
         },
@@ -82,7 +82,7 @@ export const orderSorters: SQLSortDefinitions<Order> = {
         },
         toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
             return new SQLOrderBy({
-                column: SQL.jsonValue(SQL.column('data'), '$.value.checkoutMethod.type'),
+                column: SQL.jsonExtract(SQL.column('data'), '$.value.checkoutMethod.type'),
                 direction,
             });
         },
@@ -93,7 +93,7 @@ export const orderSorters: SQLSortDefinitions<Order> = {
         },
         toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
             return new SQLOrderBy({
-                column: SQL.jsonValue(SQL.column('data'), '$.value.timeSlot.date'),
+                column: SQL.jsonExtract(SQL.column('data'), '$.value.timeSlot.date'),
                 direction,
             });
         },
@@ -104,7 +104,7 @@ export const orderSorters: SQLSortDefinitions<Order> = {
         },
         toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
             return new SQLOrderBy({
-                column: SQL.jsonValue(SQL.column('data'), '$.value.timeSlot.endTime'),
+                column: SQL.jsonExtract(SQL.column('data'), '$.value.timeSlot.endTime'),
                 direction,
             });
         },
@@ -126,7 +126,7 @@ export const orderSorters: SQLSortDefinitions<Order> = {
         },
         toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
             return new SQLOrderBy({
-                column: SQL.jsonValue(SQL.column('data'), '$.value.totalPrice'),
+                column: SQL.jsonExtract(SQL.column('data'), '$.value.totalPrice'),
                 direction,
             });
         },

package/src/sql-sorters/organizations.ts

@@ -60,7 +60,7 @@ export const organizationSorters: SQLSortDefinitions<Organization> = {
         },
         toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
             return new SQLOrderBy({
-                column: SQL.jsonValue(SQL.column('meta'), '$.value.type'),
+                column: SQL.jsonExtract(SQL.column('meta'), '$.value.type'),
                 direction,
             });
         },
@@ -71,7 +71,7 @@ export const organizationSorters: SQLSortDefinitions<Organization> = {
         },
         toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
             return new SQLOrderBy({
-                column: SQL.jsonValue(SQL.column('address'), '$.value.city'),
+                column: SQL.jsonExtract(SQL.column('address'), '$.value.city'),
                 direction,
             });
         },
@@ -82,7 +82,7 @@ export const organizationSorters: SQLSortDefinitions<Organization> = {
         },
         toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
             return new SQLOrderBy({
-                column: SQL.jsonValue(SQL.column('address'), '$.value.country'),
+                column: SQL.jsonExtract(SQL.column('address'), '$.value.country'),
                 direction,
             });
         },