@stamhoofd/backend 2.89.2 → 2.90.0

package/src/sql-filters/orders.ts

@@ -1,61 +1,109 @@
-import { baseSQLFilterCompilers, createSQLColumnFilterCompiler, createSQLExpressionFilterCompiler, SQL, SQLCast, SQLConcat, SQLFilterDefinitions, SQLJsonUnquote, SQLScalar, SQLValueType } from '@stamhoofd/sql';
+import { baseSQLFilterCompilers, createColumnFilter, SQL, SQLCast, SQLConcat, SQLJsonUnquote, SQLFilterDefinitions, SQLValueType, SQLScalar } from '@stamhoofd/sql';
 
 export const orderFilterCompilers: SQLFilterDefinitions = {
     ...baseSQLFilterCompilers,
     // only backend (not useful to filter on these in the frontend)
-    organizationId: createSQLColumnFilterCompiler('organizationId'),
-    updatedAt: createSQLColumnFilterCompiler('updatedAt'),
+    organizationId: createColumnFilter({
+        expression: SQL.column('organizationId'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    updatedAt: createColumnFilter({
+        expression: SQL.column('updatedAt'),
+        type: SQLValueType.Datetime,
+        nullable: false,
+    }),
 
     // frontend and backend
-    webshopId: createSQLColumnFilterCompiler('webshopId'),
-    id: createSQLColumnFilterCompiler('id'),
-    timeSlotEndTime: createSQLExpressionFilterCompiler(
-        SQL.jsonValue(SQL.column('data'), '$.value.timeSlot.endTime'),
-        // todo: type?
-        { isJSONValue: true, type: SQLValueType.JSONString },
-    ),
-    timeSlotStartTime: createSQLExpressionFilterCompiler(
-        SQL.jsonValue(SQL.column('data'), '$.value.timeSlot.startTime'),
-        // todo: type?
-        { isJSONValue: true, type: SQLValueType.JSONString },
-    ),
-    createdAt: createSQLColumnFilterCompiler('createdAt'),
-    number: createSQLColumnFilterCompiler('number'),
-    status: createSQLColumnFilterCompiler('status'),
-    paymentMethod: createSQLExpressionFilterCompiler(
-        SQL.jsonValue(SQL.column('data'), '$.value.paymentMethod'),
-        { isJSONValue: true, type: SQLValueType.JSONString },
-    ),
-    checkoutMethod: createSQLExpressionFilterCompiler(
-        SQL.jsonValue(SQL.column('data'), '$.value.checkoutMethod.type'),
-        { isJSONValue: true, type: SQLValueType.JSONString },
-    ),
-    timeSlotDate: createSQLExpressionFilterCompiler(
-        SQL.jsonValue(SQL.column('data'), '$.value.timeSlot.date'),
-        // todo: type?
-        { isJSONValue: true, type: SQLValueType.JSONString },
-    ),
-    validAt: createSQLColumnFilterCompiler('validAt'),
-    name: createSQLExpressionFilterCompiler(
-        new SQLCast(
+    webshopId: createColumnFilter({
+        expression: SQL.column('webshopId'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    id: createColumnFilter({
+        expression: SQL.column('id'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    timeSlotEndTime: createColumnFilter({
+        expression: SQL.jsonValue(SQL.column('data'), '$.value.timeSlot.endTime'),
+        type: SQLValueType.JSONString,
+        nullable: true,
+    }),
+    timeSlotStartTime: createColumnFilter({
+        expression: SQL.jsonValue(SQL.column('data'), '$.value.timeSlot.startTime'),
+        type: SQLValueType.JSONString,
+        nullable: true,
+    }),
+    createdAt: createColumnFilter({
+        expression: SQL.column('createdAt'),
+        type: SQLValueType.Datetime,
+        nullable: false,
+    }),
+    number: createColumnFilter({
+        expression: SQL.column('number'),
+        type: SQLValueType.Number,
+        nullable: true,
+    }),
+    status: createColumnFilter({
+        expression: SQL.column('status'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    paymentMethod: createColumnFilter({
+        expression: SQL.jsonValue(SQL.column('data'), '$.value.paymentMethod'),
+        type: SQLValueType.JSONString,
+        nullable: false,
+    }),
+    checkoutMethod: createColumnFilter({
+        expression: SQL.jsonValue(SQL.column('data'), '$.value.checkoutMethod.type'),
+        type: SQLValueType.JSONString,
+        nullable: true,
+    }),
+    timeSlotDate: createColumnFilter({
+        expression: SQL.jsonValue(SQL.column('data'), '$.value.timeSlot.date'),
+        type: SQLValueType.JSONString,
+        nullable: true,
+    }),
+    validAt: createColumnFilter({
+        expression: SQL.column('validAt'),
+        type: SQLValueType.Datetime,
+        nullable: true,
+    }),
+    name: createColumnFilter({
+        expression: new SQLCast(
             new SQLConcat(
                 new SQLJsonUnquote(SQL.jsonValue(SQL.column('data'), '$.value.customer.firstName')),
                 new SQLScalar(' '),
                 new SQLJsonUnquote(SQL.jsonValue(SQL.column('data'), '$.value.customer.lastName')),
             ),
             'CHAR'),
-    ),
-    email: createSQLExpressionFilterCompiler(
-        SQL.jsonValue(SQL.column('data'), '$.value.customer.email'),
-        // todo: type?
-        { isJSONValue: true, type: SQLValueType.JSONString },
-    ),
-    phone: createSQLExpressionFilterCompiler(
-        SQL.jsonValue(SQL.column('data'), '$.value.customer.phone'),
-        // todo: type?
-        { isJSONValue: true, type: SQLValueType.JSONString },
-    ),
-    totalPrice: createSQLColumnFilterCompiler('totalPrice'),
-    amount: createSQLColumnFilterCompiler('amount'),
-    timeSlotTime: createSQLColumnFilterCompiler('timeSlotTime'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    email: createColumnFilter({
+        expression: SQL.jsonValue(SQL.column('data'), '$.value.customer.email'),
+        type: SQLValueType.JSONString,
+        nullable: false,
+    }),
+    phone: createColumnFilter({
+        expression: SQL.jsonValue(SQL.column('data'), '$.value.customer.phone'),
+        type: SQLValueType.JSONString,
+        nullable: false,
+    }),
+    totalPrice: createColumnFilter({
+        expression: SQL.column('totalPrice'),
+        type: SQLValueType.Number,
+        nullable: false,
+    }),
+    amount: createColumnFilter({
+        expression: SQL.column('amount'),
+        type: SQLValueType.Number,
+        nullable: false,
+    }),
+    timeSlotTime: createColumnFilter({
+        expression: SQL.column('timeSlotTime'),
+        type: SQLValueType.Datetime,
+        nullable: true,
+    }),
 };

package/src/sql-filters/organization-registration-periods.ts

@@ -1,8 +1,20 @@
-import { SQLFilterDefinitions, baseSQLFilterCompilers, createSQLColumnFilterCompiler } from '@stamhoofd/sql';
+import { baseSQLFilterCompilers, createColumnFilter, SQL, SQLFilterDefinitions, SQLValueType } from '@stamhoofd/sql';
 
 export const organizationRegistrationPeriodFilterCompilers: SQLFilterDefinitions = {
     ...baseSQLFilterCompilers,
-    id: createSQLColumnFilterCompiler('id'),
-    organizationId: createSQLColumnFilterCompiler('organizationId'),
-    periodId: createSQLColumnFilterCompiler('periodId'),
+    id: createColumnFilter({
+        expression: SQL.column('id'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    organizationId: createColumnFilter({
+        expression: SQL.column('organizationId'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    periodId: createColumnFilter({
+        expression: SQL.column('periodId'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
 };

package/src/sql-filters/organizations.ts

@@ -1,112 +1,107 @@
-import {
-    SQL,
-    SQLConcat,
-    SQLExpressionOptions,
-    SQLFilterDefinitions,
-    SQLNow,
-    SQLNull,
-    SQLQuery,
-    SQLScalar,
-    SQLValueType,
-    SQLWhereEqual,
-    SQLWhereOr,
-    SQLWhereSign,
-    baseSQLFilterCompilers,
-    createSQLColumnFilterCompiler,
-    createSQLExpressionFilterCompiler,
-    createSQLFilterNamespace,
-    createSQLRelationFilterCompiler,
-} from '@stamhoofd/sql';
+import { baseSQLFilterCompilers, createColumnFilter, createExistsFilter, SQL, SQLConcat, SQLFilterDefinitions, SQLValueType, SQLNow, SQLNull, SQLScalar, SQLWhereEqual, SQLWhereOr, SQLWhereSign } from '@stamhoofd/sql';
 import { SetupStepType } from '@stamhoofd/structures';
 
 export const organizationFilterCompilers: SQLFilterDefinitions = {
     ...baseSQLFilterCompilers,
-    id: createSQLExpressionFilterCompiler(SQL.column('organizations', 'id')),
-    uriPadded: createSQLExpressionFilterCompiler(SQL.lpad(SQL.column('organizations', 'uri'), 10, '0')),
-    uri: createSQLExpressionFilterCompiler(SQL.column('organizations', 'uri')),
-    name: createSQLExpressionFilterCompiler(
-        SQL.column('organizations', 'name'),
-    ),
-    active: createSQLExpressionFilterCompiler(
-        SQL.column('organizations', 'active'),
-    ),
-    city: createSQLExpressionFilterCompiler(
-        SQL.jsonValue(SQL.column('organizations', 'address'), '$.value.city'),
-        { isJSONValue: true, type: SQLValueType.JSONString },
-    ),
-    postalCode: createSQLExpressionFilterCompiler(
-        SQL.jsonValue(SQL.column('organizations', 'address'), '$.value.postalCode'),
-        { isJSONValue: true, type: SQLValueType.JSONString },
-    ),
-    country: createSQLExpressionFilterCompiler(
-        SQL.jsonValue(
-            SQL.column('organizations', 'address'),
-            '$.value.country',
-        ),
-        { isJSONValue: true, type: SQLValueType.JSONString },
-    ),
-    umbrellaOrganization: createSQLExpressionFilterCompiler(
-        SQL.jsonValue(
-            SQL.column('organizations', 'meta'),
-            '$.value.umbrellaOrganization',
-        ),
-        { isJSONValue: true },
-    ),
-    type: createSQLExpressionFilterCompiler(
-        SQL.jsonValue(SQL.column('organizations', 'meta'), '$.value.type'),
-        { isJSONValue: true },
-    ),
-    tags: createSQLExpressionFilterCompiler(
-        SQL.jsonValue(SQL.column('organizations', 'meta'), '$.value.tags'),
-        { isJSONValue: true, isJSONObject: true },
-    ),
-    setupSteps: createSQLRelationFilterCompiler(
+    id: createColumnFilter({
+        expression: SQL.column('organizations', 'id'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    uriPadded: createColumnFilter({
+        expression: SQL.lpad(SQL.column('organizations', 'uri'), 10, '0'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    uri: createColumnFilter({
+        expression: SQL.column('organizations', 'uri'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    name: createColumnFilter({
+        expression: SQL.column('organizations', 'name'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    active: createColumnFilter({
+        expression: SQL.column('organizations', 'active'),
+        type: SQLValueType.Boolean,
+        nullable: false,
+    }),
+    city: createColumnFilter({
+        expression: SQL.jsonValue(SQL.column('organizations', 'address'), '$.value.city'),
+        type: SQLValueType.JSONString,
+        nullable: false,
+    }),
+    postalCode: createColumnFilter({
+        expression: SQL.jsonValue(SQL.column('organizations', 'address'), '$.value.postalCode'),
+        type: SQLValueType.JSONString,
+        nullable: false,
+    }),
+    country: createColumnFilter({
+        expression: SQL.jsonValue(SQL.column('organizations', 'address'), '$.value.country'),
+        type: SQLValueType.JSONString,
+        nullable: false,
+    }),
+    umbrellaOrganization: createColumnFilter({
+        expression: SQL.jsonValue(SQL.column('organizations', 'meta'), '$.value.umbrellaOrganization'),
+        type: SQLValueType.JSONString,
+        nullable: true,
+    }),
+    type: createColumnFilter({
+        expression: SQL.jsonValue(SQL.column('organizations', 'meta'), '$.value.type'),
+        type: SQLValueType.JSONString,
+        nullable: false,
+    }),
+    tags: createColumnFilter({
+        expression: SQL.jsonValue(SQL.column('organizations', 'meta'), '$.value.tags'),
+        type: SQLValueType.JSONArray,
+        nullable: false,
+    }),
+    setupSteps: createExistsFilter(
         SQL.select()
             .from(SQL.table('organization_registration_periods'))
             .where(
-                SQL.column(
-                    'organization_registration_periods',
-                    'organizationId',
-                ),
+                SQL.column('organization_registration_periods', 'organizationId'),
                 SQL.column('organizations', 'id'),
             ),
         {
             ...baseSQLFilterCompilers,
-            periodId: createSQLColumnFilterCompiler(
-                SQL.column('organization_registration_periods', 'periodId'),
-            ),
+            periodId: createColumnFilter({
+                expression: SQL.column('organization_registration_periods', 'periodId'),
+                type: SQLValueType.String,
+                nullable: false,
+            }),
             ...Object.fromEntries(
                 Object.values(SetupStepType)
                     .map((setupStep) => {
                         return [
                             setupStep,
-                            createSQLFilterNamespace({
-                                reviewedAt: createSQLExpressionFilterCompiler(
-                                    SQL.jsonValue(
-                                        SQL.column(
-                                            'organization_registration_periods',
-                                            'setupSteps',
-                                        ),
+                            {
+                                ...baseSQLFilterCompilers,
+                                reviewedAt: createColumnFilter({
+                                    expression: SQL.jsonValue(
+                                        SQL.column('organization_registration_periods', 'setupSteps'),
                                         `$.value.steps.${setupStep}.review.date`,
                                     ),
-                                    { isJSONValue: true, isJSONObject: false },
-                                ),
-                                complete: createSQLExpressionFilterCompiler(
-                                    {
-                                        getSQL: (
-                                            _options?: SQLExpressionOptions,
-                                        ): SQLQuery =>
+                                    type: SQLValueType.JSONString,
+                                    nullable: true,
+                                }),
+                                complete: createColumnFilter({
+                                    expression: {
+                                        getSQL: () =>
                                             `case when CAST(JSON_UNQUOTE(JSON_EXTRACT(\`organization_registration_periods\`.\`setupSteps\`, "$.value.steps.${setupStep}.finishedSteps")) AS unsigned) >= CAST(JSON_UNQUOTE(JSON_EXTRACT(\`organization_registration_periods\`.\`setupSteps\`, "$.value.steps.${setupStep}.totalSteps")) AS unsigned) then 1 else 0 end`,
                                     },
-                                    { isJSONValue: false, isJSONObject: false },
-                                ),
-                            }),
+                                    type: SQLValueType.Boolean,
+                                    nullable: false,
+                                }),
+                            },
                         ];
                     }),
             ),
         },
     ),
-    packages: createSQLRelationFilterCompiler(
+    packages: createExistsFilter(
         SQL.select()
             .from(SQL.table('stamhoofd_packages'))
             .where(
@@ -142,18 +137,16 @@ export const organizationFilterCompilers: SQLFilterDefinitions = {
                     ),
                 ]),
             ),
-
-        // const pack1 = await STPackage.where({ organizationId, validAt: { sign: "!=", value: null }, removeAt: { sign: ">", value: new Date() }})
-        // const pack2 = await STPackage.where({ organizationId, validAt: { sign: "!=", value: null }, removeAt: null })
         {
             ...baseSQLFilterCompilers,
-            type: createSQLExpressionFilterCompiler(
-                SQL.jsonValue(SQL.column('meta'), '$.value.type'),
-                { isJSONValue: true },
-            ),
+            type: createColumnFilter({
+                expression: SQL.jsonValue(SQL.column('meta'), '$.value.type'),
+                type: SQLValueType.JSONString,
+                nullable: false,
+            }),
         },
     ),
-    members: createSQLRelationFilterCompiler(
+    members: createExistsFilter(
         SQL.select()
             .from(SQL.table('members'))
             .join(
@@ -166,19 +159,32 @@ export const organizationFilterCompilers: SQLFilterDefinitions = {
                 SQL.column('registrations', 'organizationId'),
                 SQL.column('organizations', 'id'),
             ),
-
         {
             ...baseSQLFilterCompilers,
-            name: createSQLExpressionFilterCompiler(
-                new SQLConcat(
+            name: createColumnFilter({
+                expression: new SQLConcat(
                     SQL.column('firstName'),
                     new SQLScalar(' '),
                     SQL.column('lastName'),
                 ),
-            ),
-            firstName: createSQLColumnFilterCompiler('firstName'),
-            lastName: createSQLColumnFilterCompiler('lastName'),
-            email: createSQLColumnFilterCompiler('email'),
+                type: SQLValueType.String,
+                nullable: false,
+            }),
+            firstName: createColumnFilter({
+                expression: SQL.column('firstName'),
+                type: SQLValueType.String,
+                nullable: false,
+            }),
+            lastName: createColumnFilter({
+                expression: SQL.column('lastName'),
+                type: SQLValueType.String,
+                nullable: false,
+            }),
+            email: createColumnFilter({
+                expression: SQL.jsonValue(SQL.column('details'), '$.value.email'),
+                type: SQLValueType.JSONString,
+                nullable: true,
+            }),
         },
     ),
 };

package/src/sql-filters/payments.ts

@@ -1,37 +1,80 @@
-import { SQL, SQLCast, SQLConcat, SQLFilterDefinitions, SQLJsonUnquote, SQLScalar, SQLValueType, baseSQLFilterCompilers, createSQLColumnFilterCompiler, createSQLExpressionFilterCompiler, createSQLFilterNamespace, createSQLRelationFilterCompiler } from '@stamhoofd/sql';
+import { baseSQLFilterCompilers, createColumnFilter, createExistsFilter, SQL, SQLCast, SQLConcat, SQLJsonUnquote, SQLFilterDefinitions, SQLValueType, SQLScalar } from '@stamhoofd/sql';
 import { balanceItemPaymentsCompilers } from './balance-item-payments';
 
 /**
- * Defines how to filter members in the database from StamhoofdFilter objects
+ * Defines how to filter payments in the database from StamhoofdFilter objects
  */
 export const paymentFilterCompilers: SQLFilterDefinitions = {
     ...baseSQLFilterCompilers,
-    id: createSQLColumnFilterCompiler('id'),
-    method: createSQLColumnFilterCompiler('method'),
-    status: createSQLColumnFilterCompiler('status'),
-    organizationId: createSQLColumnFilterCompiler('organizationId'),
-    createdAt: createSQLColumnFilterCompiler('createdAt'),
-    updatedAt: createSQLColumnFilterCompiler('updatedAt'),
-    paidAt: createSQLColumnFilterCompiler('paidAt', { nullable: true }),
-    price: createSQLColumnFilterCompiler('price'),
-    provider: createSQLColumnFilterCompiler('provider', { nullable: true }),
-    transferDescription: createSQLColumnFilterCompiler('transferDescription', { nullable: true }),
-    customer: createSQLFilterNamespace({
+    id: createColumnFilter({
+        expression: SQL.column('id'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    method: createColumnFilter({
+        expression: SQL.column('method'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    status: createColumnFilter({
+        expression: SQL.column('status'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    organizationId: createColumnFilter({
+        expression: SQL.column('organizationId'),
+        type: SQLValueType.String,
+        nullable: true,
+    }),
+    createdAt: createColumnFilter({
+        expression: SQL.column('createdAt'),
+        type: SQLValueType.Datetime,
+        nullable: false,
+    }),
+    updatedAt: createColumnFilter({
+        expression: SQL.column('updatedAt'),
+        type: SQLValueType.Datetime,
+        nullable: false,
+    }),
+    paidAt: createColumnFilter({
+        expression: SQL.column('paidAt'),
+        type: SQLValueType.Datetime,
+        nullable: true,
+    }),
+    price: createColumnFilter({
+        expression: SQL.column('price'),
+        type: SQLValueType.Number,
+        nullable: false,
+    }),
+    provider: createColumnFilter({
+        expression: SQL.column('provider'),
+        type: SQLValueType.String,
+        nullable: true,
+    }),
+    transferDescription: createColumnFilter({
+        expression: SQL.column('transferDescription'),
+        type: SQLValueType.String,
+        nullable: true,
+    }),
+    customer: {
         ...baseSQLFilterCompilers,
-        email: createSQLExpressionFilterCompiler(
-            SQL.jsonValue(SQL.column('customer'), '$.value.email'),
-            { isJSONValue: true },
-        ),
-        firstName: createSQLExpressionFilterCompiler(
-            SQL.jsonValue(SQL.column('customer'), '$.value.firstName'),
-            { isJSONValue: true, type: SQLValueType.JSONString },
-        ),
-        lastName: createSQLExpressionFilterCompiler(
-            SQL.jsonValue(SQL.column('customer'), '$.value.lastName'),
-            { isJSONValue: true, type: SQLValueType.JSONString },
-        ),
-        name: createSQLExpressionFilterCompiler(
-            new SQLCast(
+        email: createColumnFilter({
+            expression: SQL.jsonValue(SQL.column('customer'), '$.value.email'),
+            type: SQLValueType.JSONString,
+            nullable: true,
+        }),
+        firstName: createColumnFilter({
+            expression: SQL.jsonValue(SQL.column('customer'), '$.value.firstName'),
+            type: SQLValueType.JSONString,
+            nullable: true,
+        }),
+        lastName: createColumnFilter({
+            expression: SQL.jsonValue(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 SQLScalar(' '),
@@ -39,27 +82,34 @@ export const paymentFilterCompilers: SQLFilterDefinitions = {
                 ),
                 'CHAR',
             ),
-        ),
-        company: createSQLFilterNamespace({
-            name: createSQLExpressionFilterCompiler(
-                SQL.jsonValue(SQL.column('customer'), '$.value.company.name'),
-                { isJSONValue: true, type: SQLValueType.JSONString },
-            ),
-            VATNumber: createSQLExpressionFilterCompiler(
-                SQL.jsonValue(SQL.column('customer'), '$.value.company.VATNumber'),
-                { isJSONValue: true, type: SQLValueType.JSONString },
-            ),
-            companyNumber: createSQLExpressionFilterCompiler(
-                SQL.jsonValue(SQL.column('customer'), '$.value.company.companyNumber'),
-                { isJSONValue: true, type: SQLValueType.JSONString },
-            ),
-            administrationEmail: createSQLExpressionFilterCompiler(
-                SQL.jsonValue(SQL.column('customer'), '$.value.company.administrationEmail'),
-                { isJSONValue: true, type: SQLValueType.JSONString },
-            ),
+            type: SQLValueType.String,
+            nullable: true,
         }),
-    }),
-    balanceItemPayments: createSQLRelationFilterCompiler(
+        company: {
+            ...baseSQLFilterCompilers,
+            name: createColumnFilter({
+                expression: SQL.jsonValue(SQL.column('customer'), '$.value.company.name'),
+                type: SQLValueType.JSONString,
+                nullable: true,
+            }),
+            VATNumber: createColumnFilter({
+                expression: SQL.jsonValue(SQL.column('customer'), '$.value.company.VATNumber'),
+                type: SQLValueType.JSONString,
+                nullable: true,
+            }),
+            companyNumber: createColumnFilter({
+                expression: SQL.jsonValue(SQL.column('customer'), '$.value.company.companyNumber'),
+                type: SQLValueType.JSONString,
+                nullable: true,
+            }),
+            administrationEmail: createColumnFilter({
+                expression: SQL.jsonValue(SQL.column('customer'), '$.value.company.administrationEmail'),
+                type: SQLValueType.JSONString,
+                nullable: true,
+            }),
+        },
+    },
+    balanceItemPayments: createExistsFilter(
         SQL.select()
             .from(
                 SQL.table('balance_item_payments'),