@stamhoofd/backend 2.39.1 → 2.40.0

package/src/sql-filters/members.ts

@@ -1,7 +1,7 @@
-import { SQL, SQLAge, SQLConcat, SQLFilterDefinitions, SQLScalar, baseSQLFilterCompilers, createSQLColumnFilterCompiler, createSQLExpressionFilterCompiler, createSQLFilterNamespace, createSQLRelationFilterCompiler } from "@stamhoofd/sql";
-import { Formatter } from "@stamhoofd/utility";
-import { organizationFilterCompilers } from "./organizations";
-import { registrationFilterCompilers } from "./registrations";
+import { SQL, SQLAge, SQLConcat, SQLFilterDefinitions, SQLScalar, SQLValueType, baseSQLFilterCompilers, createSQLColumnFilterCompiler, createSQLExpressionFilterCompiler, createSQLFilterNamespace, createSQLRelationFilterCompiler } from '@stamhoofd/sql';
+import { Formatter } from '@stamhoofd/utility';
+import { organizationFilterCompilers } from './organizations';
+import { registrationFilterCompilers } from './registrations';
 
 /**
  * Defines how to filter members in the database from StamhoofdFilter objects
@@ -17,78 +17,78 @@ export const memberFilterCompilers: SQLFilterDefinitions = {
             SQL.column('firstName'),
             new SQLScalar(' '),
             SQL.column('lastName'),
-        )
+        ),
     ),
     age: createSQLExpressionFilterCompiler(
-        new SQLAge(SQL.column('birthDay')), 
-        {nullable: true}
+        new SQLAge(SQL.column('birthDay')),
+        { nullable: true },
     ),
     gender: createSQLExpressionFilterCompiler(
         SQL.jsonValue(SQL.column('details'), '$.value.gender'),
-        {isJSONValue: true}
+        { isJSONValue: true, type: SQLValueType.JSONString },
     ),
     birthDay: createSQLColumnFilterCompiler('birthDay', {
         normalizeValue: (d) => {
             if (typeof d === 'number') {
-                const date = new Date(d)
+                const date = new Date(d);
                 return Formatter.dateIso(date);
             }
             return d;
-        }
+        },
     }),
     organizationName: createSQLExpressionFilterCompiler(
-        SQL.column('organizations', 'name')
+        SQL.column('organizations', 'name'),
     ),
 
     email: createSQLExpressionFilterCompiler(
         SQL.jsonValue(SQL.column('details'), '$.value.email'),
-        {isJSONValue: true}
+        { isJSONValue: true, type: SQLValueType.JSONString },
     ),
 
     parentEmail: createSQLExpressionFilterCompiler(
         SQL.jsonValue(SQL.column('details'), '$.value.parents[*].email'),
-        {isJSONValue: true, isJSONObject: true}
+        { isJSONValue: true, isJSONObject: true, type: SQLValueType.JSONString },
     ),
 
     unverifiedEmail: createSQLExpressionFilterCompiler(
         SQL.jsonValue(SQL.column('details'), '$.value.unverifiedEmails'),
-        {isJSONValue: true, isJSONObject: true}
+        { isJSONValue: true, isJSONObject: true, type: SQLValueType.JSONString },
     ),
 
     phone: createSQLExpressionFilterCompiler(
         SQL.jsonValue(SQL.column('details'), '$.value.phone'),
-        {isJSONValue: true}
+        { isJSONValue: true },
     ),
 
     parentPhone: createSQLExpressionFilterCompiler(
         SQL.jsonValue(SQL.column('details'), '$.value.parents[*].phone'),
-        {isJSONValue: true, isJSONObject: true}
+        { isJSONValue: true, isJSONObject: true },
     ),
 
     unverifiedPhone: createSQLExpressionFilterCompiler(
         SQL.jsonValue(SQL.column('details'), '$.value.unverifiedPhones'),
-        {isJSONValue: true, isJSONObject: true}
+        { isJSONValue: true, isJSONObject: true },
     ),
 
     registrations: createSQLRelationFilterCompiler(
         SQL.select()
             .from(
-                SQL.table('registrations')
+                SQL.table('registrations'),
             ).join(
                 SQL.join(
-                    SQL.table('groups')
+                    SQL.table('groups'),
                 ).where(
                     SQL.column('groups', 'id'),
-                    SQL.column('registrations', 'groupId')
-                )
+                    SQL.column('registrations', 'groupId'),
+                ),
             )
             .join(
                 SQL.join(
-                    SQL.table('organizations')
+                    SQL.table('organizations'),
                 ).where(
                     SQL.column('organizations', 'id'),
-                    SQL.column('registrations', 'organizationId')
-                )
+                    SQL.column('registrations', 'organizationId'),
+                ),
             )
             .where(
                 SQL.column('memberId'),
@@ -101,102 +101,102 @@ export const memberFilterCompilers: SQLFilterDefinitions = {
                 null,
             ).where(
                 SQL.column('groups', 'deletedAt'),
-                null
+                null,
             ),
         {
             ...registrationFilterCompilers,
-            "organization": createSQLFilterNamespace(organizationFilterCompilers)
-        }
+            organization: createSQLFilterNamespace(organizationFilterCompilers),
+        },
     ),
 
     responsibilities: createSQLRelationFilterCompiler(
         SQL.select()
-        .from(
-            SQL.table('member_responsibility_records')
-        )
-        .join(
-            SQL.leftJoin(
-                SQL.table('groups')
-            ).where(
-                SQL.column('groups', 'id'),
-                SQL.column('member_responsibility_records', 'groupId')
+            .from(
+                SQL.table('member_responsibility_records'),
             )
-        )
-        .where(
-            SQL.column('memberId'),
-            SQL.column('members', 'id'),
-        ),
+            .join(
+                SQL.leftJoin(
+                    SQL.table('groups'),
+                ).where(
+                    SQL.column('groups', 'id'),
+                    SQL.column('member_responsibility_records', 'groupId'),
+                ),
+            )
+            .where(
+                SQL.column('memberId'),
+                SQL.column('members', 'id'),
+            ),
         {
             ...baseSQLFilterCompilers,
             // Alias for responsibilityId
-            "id": createSQLColumnFilterCompiler(SQL.column('member_responsibility_records', 'responsibilityId')),
-            "responsibilityId": createSQLColumnFilterCompiler(SQL.column('member_responsibility_records', 'responsibilityId')),
-            "organizationId": createSQLColumnFilterCompiler(SQL.column('member_responsibility_records', 'organizationId')),
-            "startDate": createSQLColumnFilterCompiler(SQL.column('member_responsibility_records', 'startDate')),
-            "endDate": createSQLColumnFilterCompiler(SQL.column('member_responsibility_records', 'endDate')),
-            "group": createSQLFilterNamespace({
+            id: createSQLColumnFilterCompiler(SQL.column('member_responsibility_records', 'responsibilityId')),
+            responsibilityId: createSQLColumnFilterCompiler(SQL.column('member_responsibility_records', 'responsibilityId')),
+            organizationId: createSQLColumnFilterCompiler(SQL.column('member_responsibility_records', 'organizationId')),
+            startDate: createSQLColumnFilterCompiler(SQL.column('member_responsibility_records', 'startDate')),
+            endDate: createSQLColumnFilterCompiler(SQL.column('member_responsibility_records', 'endDate')),
+            group: createSQLFilterNamespace({
                 ...baseSQLFilterCompilers,
                 id: createSQLColumnFilterCompiler(SQL.column('groups', 'id')),
                 defaultAgeGroupId: createSQLColumnFilterCompiler(SQL.column('groups', 'defaultAgeGroupId')),
-            })
-        }
+            }),
+        },
     ),
 
     platformMemberships: createSQLRelationFilterCompiler(
         SQL.select()
-        .from(
-            SQL.table('member_platform_memberships')
-        )
-        .where(
-            SQL.column('memberId'),
-            SQL.column('members', 'id'),
-        )
-        .where(
-            SQL.column('deletedAt'),
-            null,
-        ),
+            .from(
+                SQL.table('member_platform_memberships'),
+            )
+            .where(
+                SQL.column('memberId'),
+                SQL.column('members', 'id'),
+            )
+            .where(
+                SQL.column('deletedAt'),
+                null,
+            ),
         {
             ...baseSQLFilterCompilers,
-            "id": createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'id')),
-            "membershipTypeId": createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'membershipTypeId')),
-            "organizationId": createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'organizationId')),
-            "periodId": createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'periodId')),
-            "price": createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'price')),
-            "invoiceId": createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'invoiceId')),
-            "startDate": createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'startDate')),
-            "endDate": createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'endDate')),
-            "expireDate": createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'expireDate')),
-        }
+            id: createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'id')),
+            membershipTypeId: createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'membershipTypeId')),
+            organizationId: createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'organizationId')),
+            periodId: createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'periodId')),
+            price: createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'price')),
+            invoiceId: createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'invoiceId')),
+            startDate: createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'startDate')),
+            endDate: createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'endDate')),
+            expireDate: createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'expireDate')),
+        },
     ),
 
     organizations: createSQLRelationFilterCompiler(
         SQL.select()
-        .from(
-            SQL.table('registrations')
-        ).join(
-            SQL.join(
-                SQL.table('groups')
+            .from(
+                SQL.table('registrations'),
+            ).join(
+                SQL.join(
+                    SQL.table('groups'),
+                ).where(
+                    SQL.column('groups', 'id'),
+                    SQL.column('registrations', 'groupId'),
+                ),
+            ).join(
+                SQL.join(
+                    SQL.table('organizations'),
+                ).where(
+                    SQL.column('organizations', 'id'),
+                    SQL.column('registrations', 'organizationId'),
+                ),
             ).where(
-                SQL.column('groups', 'id'),
-                SQL.column('registrations', 'groupId')
-            )
-        ).join(
-            SQL.join(
-                SQL.table('organizations')
+                SQL.column('memberId'),
+                SQL.column('members', 'id'),
+            ).whereNot(
+                SQL.column('registeredAt'),
+                null,
             ).where(
-                SQL.column('organizations', 'id'),
-                SQL.column('registrations', 'organizationId')
-            )
-        ).where(
-            SQL.column('memberId'),
-            SQL.column('members', 'id'),
-        ).whereNot(
-            SQL.column('registeredAt'),
-            null,
-        ).where(
-            SQL.column('groups', 'deletedAt'),
-            null
-        ),
-        organizationFilterCompilers
+                SQL.column('groups', 'deletedAt'),
+                null,
+            ),
+        organizationFilterCompilers,
     ),
-}
+};

package/src/sql-filters/organizations.ts

@@ -1,102 +1,166 @@
-import { SQL, SQLConcat, SQLFilterDefinitions, SQLNow, SQLNull, SQLScalar, SQLWhereEqual, SQLWhereOr, SQLWhereSign, baseSQLFilterCompilers, createSQLColumnFilterCompiler, createSQLExpressionFilterCompiler, createSQLRelationFilterCompiler } from "@stamhoofd/sql";
+import {
+    SQL,
+    SQLConcat,
+    SQLExpressionOptions,
+    SQLFilterDefinitions,
+    SQLNow,
+    SQLNull,
+    SQLQuery,
+    SQLScalar,
+    SQLValueType,
+    SQLWhereEqual,
+    SQLWhereOr,
+    SQLWhereSign,
+    baseSQLFilterCompilers,
+    createSQLColumnFilterCompiler,
+    createSQLExpressionFilterCompiler,
+    createSQLFilterNamespace,
+    createSQLRelationFilterCompiler,
+} from '@stamhoofd/sql';
+import { SetupStepType } from '@stamhoofd/structures';
 
 export const organizationFilterCompilers: SQLFilterDefinitions = {
     ...baseSQLFilterCompilers,
-    id: createSQLExpressionFilterCompiler(
-        SQL.column('organizations', 'id')
-    ),
-    uri: createSQLExpressionFilterCompiler(
-        SQL.column('organizations', 'uri')
-    ),
+    id: createSQLExpressionFilterCompiler(SQL.column('organizations', 'id')),
+    uri: createSQLExpressionFilterCompiler(SQL.column('organizations', 'uri')),
     name: createSQLExpressionFilterCompiler(
-        SQL.column('organizations', 'name')
+        SQL.column('organizations', 'name'),
     ),
     active: createSQLExpressionFilterCompiler(
-        SQL.column('organizations', 'active')
+        SQL.column('organizations', 'active'),
     ),
     city: createSQLExpressionFilterCompiler(
         SQL.jsonValue(SQL.column('organizations', 'address'), '$.value.city'),
-        {isJSONValue: true}
+        { isJSONValue: true, type: SQLValueType.JSONString },
     ),
     country: createSQLExpressionFilterCompiler(
-        SQL.jsonValue(SQL.column('organizations', 'address'), '$.value.country'),
-        {isJSONValue: true}
+        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}
+        SQL.jsonValue(
+            SQL.column('organizations', 'meta'),
+            '$.value.umbrellaOrganization',
+        ),
+        { isJSONValue: true },
     ),
     type: createSQLExpressionFilterCompiler(
         SQL.jsonValue(SQL.column('organizations', 'meta'), '$.value.type'),
-        {isJSONValue: true}
+        { isJSONValue: true },
     ),
     tags: createSQLExpressionFilterCompiler(
         SQL.jsonValue(SQL.column('organizations', 'meta'), '$.value.tags'),
-        {isJSONValue: true, isJSONObject: true}
+        { isJSONValue: true, isJSONObject: true },
     ),
-    packages: createSQLRelationFilterCompiler(
-        SQL.select().from(
-            SQL.table('stamhoofd_packages')
-        ).where(
-            SQL.column('organizationId'),
-            SQL.column('organizations', 'id'),
-        )
-        .where(
-            SQL.column('validAt'),
-            SQLWhereSign.NotEqual,
-            new SQLNull()
-        ).where(
-            new SQLWhereOr([
-                new SQLWhereEqual(
-                    SQL.column('validUntil'),
-                    SQLWhereSign.Equal,
-                    new SQLNull()
-                ),
-                new SQLWhereEqual(
-                    SQL.column('validUntil'),
-                    SQLWhereSign.Greater,
-                    new SQLNow()
-                )
-            ])
-        ).where(
-            new SQLWhereOr([
-                new SQLWhereEqual(
-                    SQL.column('removeAt'),
-                    SQLWhereSign.Equal,
-                    new SQLNull()
+    setupSteps: createSQLRelationFilterCompiler(
+        SQL.select()
+            .from(SQL.table('organization_registration_periods'))
+            .where(
+                SQL.column(
+                    'organization_registration_periods',
+                    'organizationId',
                 ),
-                new SQLWhereEqual(
-                    SQL.column('removeAt'),
-                    SQLWhereSign.Greater,
-                    new SQLNow()
-                )
-            ])
-        ),
+                SQL.column('organizations', 'id'),
+            ),
+        {
+            ...baseSQLFilterCompilers,
+            periodId: createSQLColumnFilterCompiler(
+                SQL.column('organization_registration_periods', 'periodId'),
+            ),
+            ...Object.fromEntries(
+                Object.values(SetupStepType)
+                    .map((setupStep) => {
+                        return [
+                            setupStep,
+                            createSQLFilterNamespace({
+                                reviewedAt: createSQLExpressionFilterCompiler(
+                                    SQL.jsonValue(
+                                        SQL.column(
+                                            'organization_registration_periods',
+                                            'setupSteps',
+                                        ),
+                                        `$.value.steps.${setupStep}.review.date`,
+                                    ),
+                                    { isJSONValue: true, isJSONObject: false },
+                                ),
+                                complete: createSQLExpressionFilterCompiler(
+                                    {
+                                        getSQL: (
+                                            _options?: SQLExpressionOptions,
+                                        ): SQLQuery =>
+                                            `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 },
+                                ),
+                            }),
+                        ];
+                    }),
+            ),
+        },
+    ),
+    packages: createSQLRelationFilterCompiler(
+        SQL.select()
+            .from(SQL.table('stamhoofd_packages'))
+            .where(
+                SQL.column('organizationId'),
+                SQL.column('organizations', 'id'),
+            )
+            .where(SQL.column('validAt'), SQLWhereSign.NotEqual, new SQLNull())
+            .where(
+                new SQLWhereOr([
+                    new SQLWhereEqual(
+                        SQL.column('validUntil'),
+                        SQLWhereSign.Equal,
+                        new SQLNull(),
+                    ),
+                    new SQLWhereEqual(
+                        SQL.column('validUntil'),
+                        SQLWhereSign.Greater,
+                        new SQLNow(),
+                    ),
+                ]),
+            )
+            .where(
+                new SQLWhereOr([
+                    new SQLWhereEqual(
+                        SQL.column('removeAt'),
+                        SQLWhereSign.Equal,
+                        new SQLNull(),
+                    ),
+                    new SQLWhereEqual(
+                        SQL.column('removeAt'),
+                        SQLWhereSign.Greater,
+                        new SQLNow(),
+                    ),
+                ]),
+            ),
 
         // 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(
+            type: createSQLExpressionFilterCompiler(
                 SQL.jsonValue(SQL.column('meta'), '$.value.type'),
-                {isJSONValue: true}
-            )
-        }
+                { isJSONValue: true },
+            ),
+        },
     ),
     members: createSQLRelationFilterCompiler(
-        SQL.select().from(
-            SQL.table('members')
-        ).join(
-            SQL.join(
-                SQL.table('registrations')
-            ).where(
-                SQL.column('members', 'id'),
-                SQL.column('registrations', 'memberId')
+        SQL.select()
+            .from(SQL.table('members'))
+            .join(
+                SQL.join(SQL.table('registrations')).where(
+                    SQL.column('members', 'id'),
+                    SQL.column('registrations', 'memberId'),
+                ),
             )
-        ).where(
-            SQL.column('registrations', 'organizationId'),
-            SQL.column('organizations', 'id'),
-        ),
+            .where(
+                SQL.column('registrations', 'organizationId'),
+                SQL.column('organizations', 'id'),
+            ),
 
         {
             ...baseSQLFilterCompilers,
@@ -105,11 +169,11 @@ export const organizationFilterCompilers: SQLFilterDefinitions = {
                     SQL.column('firstName'),
                     new SQLScalar(' '),
                     SQL.column('lastName'),
-                )
+                ),
             ),
-            "firstName": createSQLColumnFilterCompiler('firstName'),
-            "lastName": createSQLColumnFilterCompiler('lastName'),
-            "email": createSQLColumnFilterCompiler('email')
-        }
+            firstName: createSQLColumnFilterCompiler('firstName'),
+            lastName: createSQLColumnFilterCompiler('lastName'),
+            email: createSQLColumnFilterCompiler('email'),
+        },
     ),
-}
+};

package/src/sql-filters/payments.ts

@@ -1,5 +1,5 @@
-import { SQL, SQLCast, SQLConcat, SQLFilterDefinitions, SQLJsonUnquote, SQLScalar, baseSQLFilterCompilers, createSQLColumnFilterCompiler, createSQLExpressionFilterCompiler, createSQLFilterNamespace, createSQLRelationFilterCompiler } from "@stamhoofd/sql";
-import { balanceItemPaymentsCompilers } from "./balance-item-payments";
+import { SQL, SQLCast, SQLConcat, SQLFilterDefinitions, SQLJsonUnquote, SQLScalar, SQLValueType, baseSQLFilterCompilers, createSQLColumnFilterCompiler, createSQLExpressionFilterCompiler, createSQLFilterNamespace, createSQLRelationFilterCompiler } from '@stamhoofd/sql';
+import { balanceItemPaymentsCompilers } from './balance-item-payments';
 
 /**
  * Defines how to filter members in the database from StamhoofdFilter objects
@@ -12,22 +12,22 @@ export const paymentFilterCompilers: SQLFilterDefinitions = {
     organizationId: createSQLColumnFilterCompiler('organizationId'),
     createdAt: createSQLColumnFilterCompiler('createdAt'),
     updatedAt: createSQLColumnFilterCompiler('updatedAt'),
-    paidAt: createSQLColumnFilterCompiler('paidAt', {nullable: true}),
+    paidAt: createSQLColumnFilterCompiler('paidAt', { nullable: true }),
     price: createSQLColumnFilterCompiler('price'),
-    provider: createSQLColumnFilterCompiler('provider', {nullable: true}),
+    provider: createSQLColumnFilterCompiler('provider', { nullable: true }),
     customer: createSQLFilterNamespace({
         ...baseSQLFilterCompilers,
         email: createSQLExpressionFilterCompiler(
             SQL.jsonValue(SQL.column('customer'), '$.value.email'),
-            {isJSONValue: true}
+            { isJSONValue: true },
         ),
         firstName: createSQLExpressionFilterCompiler(
             SQL.jsonValue(SQL.column('customer'), '$.value.firstName'),
-            {isJSONValue: true}
+            { isJSONValue: true, type: SQLValueType.JSONString },
         ),
         lastName: createSQLExpressionFilterCompiler(
             SQL.jsonValue(SQL.column('customer'), '$.value.lastName'),
-            {isJSONValue: true}
+            { isJSONValue: true, type: SQLValueType.JSONString },
         ),
         name: createSQLExpressionFilterCompiler(
             new SQLCast(
@@ -36,43 +36,43 @@ export const paymentFilterCompilers: SQLFilterDefinitions = {
                     new SQLScalar(' '),
                     new SQLJsonUnquote(SQL.jsonValue(SQL.column('customer'), '$.value.lastName')),
                 ),
-                'CHAR'
-            )
+                'CHAR',
+            ),
         ),
         company: createSQLFilterNamespace({
             name: createSQLExpressionFilterCompiler(
                 SQL.jsonValue(SQL.column('customer'), '$.value.company.name'),
-                {isJSONValue: true}
+                { isJSONValue: true, type: SQLValueType.JSONString },
             ),
             VATNumber: createSQLExpressionFilterCompiler(
                 SQL.jsonValue(SQL.column('customer'), '$.value.company.VATNumber'),
-                {isJSONValue: true}
+                { isJSONValue: true, type: SQLValueType.JSONString },
             ),
             companyNumber: createSQLExpressionFilterCompiler(
                 SQL.jsonValue(SQL.column('customer'), '$.value.company.companyNumber'),
-                {isJSONValue: true}
+                { isJSONValue: true, type: SQLValueType.JSONString },
             ),
             administrationEmail: createSQLExpressionFilterCompiler(
                 SQL.jsonValue(SQL.column('customer'), '$.value.company.administrationEmail'),
-                {isJSONValue: true}
+                { isJSONValue: true, type: SQLValueType.JSONString },
             ),
-        })
+        }),
     }),
     balanceItemPayments: createSQLRelationFilterCompiler(
         SQL.select()
-        .from(
-            SQL.table('balance_item_payments')
-        ).join(
-            SQL.join(
-                SQL.table('balance_items')
+            .from(
+                SQL.table('balance_item_payments'),
+            ).join(
+                SQL.join(
+                    SQL.table('balance_items'),
+                ).where(
+                    SQL.column('balance_items', 'id'),
+                    SQL.column('balance_item_payments', 'balanceItemId'),
+                ),
             ).where(
-                SQL.column('balance_items', 'id'),
-                SQL.column('balance_item_payments', 'balanceItemId')
-            )
-        ).where(
-            SQL.column('paymentId'),
-            SQL.column('payments', 'id')
-        ),
-        balanceItemPaymentsCompilers
+                SQL.column('paymentId'),
+                SQL.column('payments', 'id'),
+            ),
+        balanceItemPaymentsCompilers,
     ),
-}
+};