@stamhoofd/backend 2.89.1 → 2.90.0

package/src/sql-filters/members.ts

@@ -1,8 +1,7 @@
 import { SimpleError } from '@simonbackx/simple-errors';
 import { Member } from '@stamhoofd/models';
-import { SQL, SQLAge, SQLConcat, SQLFilterDefinitions, SQLScalar, SQLValueType, baseSQLFilterCompilers, createSQLColumnFilterCompiler, createSQLExpressionFilterCompiler, createSQLFilterNamespace, createSQLRelationFilterCompiler } from '@stamhoofd/sql';
+import { baseSQLFilterCompilers, createColumnFilter, createExistsFilter, SQL, SQLAge, SQLCast, SQLConcat, SQLFilterDefinitions, SQLValueType, SQLScalar, createWildcardColumnFilter, SQLJsonExtract } from '@stamhoofd/sql';
 import { AccessRight } from '@stamhoofd/structures';
-import { Formatter } from '@stamhoofd/utility';
 import { Context } from '../helpers/Context';
 import { baseRegistrationFilterCompilers } from './base-registration-filter-compilers';
 import { organizationFilterCompilers } from './organizations';
@@ -14,42 +13,71 @@ const membersTable = SQL.table(Member.table);
  */
 export const memberFilterCompilers: SQLFilterDefinitions = {
     ...baseSQLFilterCompilers,
-    'id': createSQLColumnFilterCompiler(SQL.column(membersTable, 'id')),
-    'memberNumber': createSQLColumnFilterCompiler(SQL.column(membersTable, 'memberNumber')),
-    'firstName': createSQLColumnFilterCompiler(SQL.column(membersTable, 'firstName')),
-    'lastName': createSQLColumnFilterCompiler(SQL.column(membersTable, 'lastName')),
-    'name': createSQLExpressionFilterCompiler(
-        new SQLConcat(
+    'id': createColumnFilter({
+        expression: SQL.column(membersTable, 'id'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    'memberNumber': createColumnFilter({
+        expression: SQL.column(membersTable, 'memberNumber'),
+        type: SQLValueType.Number,
+        nullable: true,
+    }),
+    'firstName': createColumnFilter({
+        expression: SQL.column(membersTable, 'firstName'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    'lastName': createColumnFilter({
+        expression: SQL.column(membersTable, 'lastName'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    'name': createColumnFilter({
+        expression: new SQLConcat(
             SQL.column(membersTable, 'firstName'),
             new SQLScalar(' '),
             SQL.column(membersTable, 'lastName'),
         ),
-    ),
-    'age': createSQLExpressionFilterCompiler(
-        new SQLAge(SQL.column(membersTable, 'birthDay')),
-        { nullable: true },
-    ),
-    'gender': createSQLExpressionFilterCompiler(
-        SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.gender'),
-        { isJSONValue: true, type: SQLValueType.JSONString },
-    ),
-    'birthDay': createSQLColumnFilterCompiler(SQL.column(membersTable, 'birthDay'), {
-        normalizeValue: (d) => {
-            if (typeof d === 'number') {
-                const date = new Date(d);
-                return Formatter.dateIso(date);
-            }
-            return d;
-        },
+        type: SQLValueType.String,
+        nullable: false,
     }),
-    'organizationName': createSQLExpressionFilterCompiler(
-        SQL.column('organizations', 'name'),
-    ),
-    'details.requiresFinancialSupport': createSQLExpressionFilterCompiler(
-        SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.requiresFinancialSupport.value'),
-        { isJSONValue: true, type: SQLValueType.JSONBoolean, checkPermission: async () => {
+    'age': createColumnFilter({
+        expression: new SQLAge(SQL.column(membersTable, 'birthDay')),
+        type: SQLValueType.Number,
+        nullable: true,
+    }),
+    'gender': createColumnFilter({
+        expression: SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.gender'),
+        type: SQLValueType.JSONString,
+        nullable: false,
+    }),
+    'birthDay': createColumnFilter({
+        // todo: check normalization of date
+        expression: SQL.column(membersTable, 'birthDay'),
+        type: SQLValueType.Datetime,
+        nullable: true,
+    }),
+    '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'),
+        type: SQLValueType.JSONBoolean,
+        nullable: true,
+        checkPermission: async () => {
             const organization = Context.organization;
             if (!organization) {
+                if (!Context.auth.hasPlatformFullAccess()) {
+                    throw new SimpleError({
+                        code: 'permission_denied',
+                        message: 'No permissions for financial support filter.',
+                        human: $t(`64d658fa-0727-4924-9448-b243fe8e10a1`),
+                        statusCode: 400,
+                    });
+                }
                 return;
             }
 
@@ -63,89 +91,113 @@ export const memberFilterCompilers: SQLFilterDefinitions = {
                     statusCode: 400,
                 });
             }
-        } },
-    ),
-    'email': createSQLExpressionFilterCompiler(
-        SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.email'),
-        { isJSONValue: true, type: SQLValueType.JSONString },
-    ),
-    'parentEmail': createSQLExpressionFilterCompiler(
-        SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.parents[*].email'),
-        { isJSONValue: true, isJSONObject: true, type: SQLValueType.JSONString },
-    ),
-    'details.parents[0]': createSQLFilterNamespace({
-        name: createSQLExpressionFilterCompiler(
-            new SQLConcat(
-                SQL.jsonUnquotedValue(SQL.column(membersTable, 'details'), '$.value.parents[0].firstName'),
-                new SQLScalar(' '),
-                SQL.jsonUnquotedValue(SQL.column(membersTable, 'details'), '$.value.parents[0].lastName'),
-            ),
-            { isJSONValue: true, isJSONObject: false, type: SQLValueType.JSONString },
-        ),
+        },
     }),
-    'details.parents[1]': createSQLFilterNamespace({
-        name: createSQLExpressionFilterCompiler(
-            new SQLConcat(
-                SQL.jsonUnquotedValue(SQL.column(membersTable, 'details'), '$.value.parents[1].firstName'),
-                new SQLScalar(' '),
-                SQL.jsonUnquotedValue(SQL.column(membersTable, 'details'), '$.value.parents[1].lastName'),
-            ),
-            { isJSONValue: true, isJSONObject: false, type: SQLValueType.JSONString },
-        ),
+    'email': createColumnFilter({
+        expression: SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.email'),
+        type: SQLValueType.JSONString,
+        nullable: true,
     }),
-    'unverifiedEmail': createSQLExpressionFilterCompiler(
-        SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.unverifiedEmails'),
-        { isJSONValue: true, isJSONObject: true, type: SQLValueType.JSONString },
-    ),
-    'phone': createSQLExpressionFilterCompiler(
-        SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.phone'),
-        { isJSONValue: true },
-    ),
-    'details.address': createSQLFilterNamespace({
-        city: createSQLExpressionFilterCompiler(
-            SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.address.city'),
-            { isJSONValue: true, type: SQLValueType.JSONString },
-        ),
-        postalCode: createSQLExpressionFilterCompiler(
-            SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.address.postalCode'),
-            { isJSONValue: true, type: SQLValueType.JSONString },
-        ),
-        street: createSQLExpressionFilterCompiler(
-            SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.address.street'),
-            { isJSONValue: true, type: SQLValueType.JSONString },
-        ),
-        number: createSQLExpressionFilterCompiler(
-            SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.address.number'),
-            { isJSONValue: true, type: SQLValueType.JSONString },
-        ),
+    'parentEmail': createColumnFilter({
+        expression: SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.parents[*].email'),
+        type: SQLValueType.JSONArray,
+        nullable: true,
     }),
-    'details.parents[*].address': createSQLFilterNamespace({
-        city: createSQLExpressionFilterCompiler(
-            SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.parents[*].address.city'),
-            { isJSONValue: true, isJSONObject: true },
-        ),
-        postalCode: createSQLExpressionFilterCompiler(
-            SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.parents[*].address.postalCode'),
-            { isJSONValue: true, isJSONObject: true },
-        ),
-        street: createSQLExpressionFilterCompiler(
-            SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.parents[*].address.street'),
-            { isJSONValue: true, isJSONObject: true },
-        ),
-        number: createSQLExpressionFilterCompiler(
-            SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.parents[*].address.number'),
-            { isJSONValue: true, isJSONObject: true },
-        ),
+    'details.parents[0]': {
+        ...baseSQLFilterCompilers,
+        name: createColumnFilter({
+            expression: new SQLCast(
+                new SQLConcat(
+                    SQL.jsonUnquotedValue(SQL.column(membersTable, 'details'), '$.value.parents[0].firstName'),
+                    new SQLScalar(' '),
+                    SQL.jsonUnquotedValue(SQL.column(membersTable, 'details'), '$.value.parents[0].lastName'),
+                ),
+                'CHAR'),
+            type: SQLValueType.String,
+            nullable: true,
+        }),
+    },
+    'details.parents[1]': {
+        ...baseSQLFilterCompilers,
+        name: createColumnFilter({
+            expression: new SQLCast(
+                new SQLConcat(
+                    SQL.jsonUnquotedValue(SQL.column(membersTable, 'details'), '$.value.parents[1].firstName'),
+                    new SQLScalar(' '),
+                    SQL.jsonUnquotedValue(SQL.column(membersTable, 'details'), '$.value.parents[1].lastName'),
+                ),
+                'CHAR'),
+            type: SQLValueType.String,
+            nullable: true,
+        }),
+    },
+    'unverifiedEmail': createColumnFilter({
+        expression: SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.unverifiedEmails'),
+        type: SQLValueType.JSONArray,
+        nullable: true,
     }),
-    'parentPhone': createSQLExpressionFilterCompiler(
-        SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.parents[*].phone'),
-        { isJSONValue: true, isJSONObject: true },
-    ),
-    'unverifiedPhone': createSQLExpressionFilterCompiler(
-        SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.unverifiedPhones'),
-        { isJSONValue: true, isJSONObject: true },
-    ),
-    'registrations': createSQLRelationFilterCompiler(
+    'phone': createColumnFilter({
+        expression: SQL.jsonValue(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'),
+            type: SQLValueType.JSONString,
+            nullable: true,
+        }),
+        postalCode: createColumnFilter({
+            expression: SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.address.postalCode'),
+            type: SQLValueType.JSONString,
+            nullable: true,
+        }),
+        street: createColumnFilter({
+            expression: SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.address.street'),
+            type: SQLValueType.JSONString,
+            nullable: true,
+        }),
+        number: createColumnFilter({
+            expression: SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.address.number'),
+            type: SQLValueType.JSONString,
+            nullable: true,
+        }),
+    },
+    'details.parents[*].address': {
+        ...baseSQLFilterCompilers,
+        city: createColumnFilter({
+            expression: SQL.jsonValue(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'),
+            type: SQLValueType.JSONArray,
+            nullable: true,
+        }),
+        street: createColumnFilter({
+            expression: SQL.jsonValue(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'),
+            type: SQLValueType.JSONArray,
+            nullable: true,
+        }),
+    },
+    'parentPhone': createColumnFilter({
+        expression: SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.parents[*].phone'),
+        type: SQLValueType.JSONArray,
+        nullable: true,
+    }),
+    'unverifiedPhone': createColumnFilter({
+        expression: SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.unverifiedPhones'),
+        type: SQLValueType.JSONArray,
+        nullable: true,
+    }),
+    'registrations': createExistsFilter(
         SQL.select()
             .from(
                 SQL.table('registrations'),
@@ -173,10 +225,14 @@ export const memberFilterCompilers: SQLFilterDefinitions = {
         {
             ...baseRegistrationFilterCompilers,
             // Override the registration periodId - can be outdated - and always use the group periodId
-            periodId: createSQLColumnFilterCompiler(SQL.column('groups', 'periodId')),
+            periodId: createColumnFilter({
+                expression: SQL.column('groups', 'periodId'),
+                type: SQLValueType.String,
+                nullable: false,
+            }),
         },
     ),
-    'responsibilities': createSQLRelationFilterCompiler(
+    'responsibilities': createExistsFilter(
         SQL.select()
             .from(
                 SQL.table('member_responsibility_records'),
@@ -204,20 +260,48 @@ export const memberFilterCompilers: SQLFilterDefinitions = {
         {
             ...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({
-                ...baseSQLFilterCompilers,
-                id: createSQLColumnFilterCompiler(SQL.column('groups', 'id')),
-                defaultAgeGroupId: createSQLColumnFilterCompiler(SQL.column('groups', 'defaultAgeGroupId')),
+            id: createColumnFilter({
+                expression: SQL.column('member_responsibility_records', 'responsibilityId'),
+                type: SQLValueType.String,
+                nullable: false,
+            }),
+            responsibilityId: createColumnFilter({
+                expression: SQL.column('member_responsibility_records', 'responsibilityId'),
+                type: SQLValueType.String,
+                nullable: false,
+            }),
+            organizationId: createColumnFilter({
+                expression: SQL.column('member_responsibility_records', 'organizationId'),
+                type: SQLValueType.String,
+                nullable: false,
+            }),
+            startDate: createColumnFilter({
+                expression: SQL.column('member_responsibility_records', 'startDate'),
+                type: SQLValueType.Datetime,
+                nullable: false,
             }),
-            organization: createSQLFilterNamespace(organizationFilterCompilers),
+            endDate: createColumnFilter({
+                expression: SQL.column('member_responsibility_records', 'endDate'),
+                type: SQLValueType.Datetime,
+                nullable: true,
+            }),
+            group: {
+                ...baseSQLFilterCompilers,
+                id: createColumnFilter({
+                    expression: SQL.column('groups', 'id'),
+                    type: SQLValueType.String,
+                    nullable: false,
+                }),
+                defaultAgeGroupId: createColumnFilter({
+                    expression: SQL.column('groups', 'defaultAgeGroupId'),
+                    type: SQLValueType.String,
+                    nullable: true,
+                }),
+            },
+            organization: organizationFilterCompilers,
         },
     ),
-    'platformMemberships': createSQLRelationFilterCompiler(
+    'platformMemberships': createExistsFilter(
         SQL.select()
             .from(
                 SQL.table('member_platform_memberships'),
@@ -232,22 +316,74 @@ export const memberFilterCompilers: SQLFilterDefinitions = {
             ),
         {
             ...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')),
-            priceWithoutDiscount: createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'priceWithoutDiscount')),
-            startDate: createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'startDate')),
-            endDate: createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'endDate')),
-            expireDate: createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'expireDate')),
-            trialUntil: createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'trialUntil')),
-            locked: createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'locked')),
-            balanceItemId: createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'balanceItemId')),
-            generated: createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'generated')),
+            id: createColumnFilter({
+                expression: SQL.column('member_platform_memberships', 'id'),
+                type: SQLValueType.String,
+                nullable: false,
+            }),
+            membershipTypeId: createColumnFilter({
+                expression: SQL.column('member_platform_memberships', 'membershipTypeId'),
+                type: SQLValueType.String,
+                nullable: false,
+            }),
+            organizationId: createColumnFilter({
+                expression: SQL.column('member_platform_memberships', 'organizationId'),
+                type: SQLValueType.String,
+                nullable: false,
+            }),
+            periodId: createColumnFilter({
+                expression: SQL.column('member_platform_memberships', 'periodId'),
+                type: SQLValueType.String,
+                nullable: false,
+            }),
+            price: createColumnFilter({
+                expression: SQL.column('member_platform_memberships', 'price'),
+                type: SQLValueType.Number,
+                nullable: false,
+            }),
+            priceWithoutDiscount: createColumnFilter({
+                expression: SQL.column('member_platform_memberships', 'priceWithoutDiscount'),
+                type: SQLValueType.Number,
+                nullable: false,
+            }),
+            startDate: createColumnFilter({
+                expression: SQL.column('member_platform_memberships', 'startDate'),
+                type: SQLValueType.Datetime,
+                nullable: false,
+            }),
+            endDate: createColumnFilter({
+                expression: SQL.column('member_platform_memberships', 'endDate'),
+                type: SQLValueType.Datetime,
+                nullable: false,
+            }),
+            expireDate: createColumnFilter({
+                expression: SQL.column('member_platform_memberships', 'expireDate'),
+                type: SQLValueType.Datetime,
+                nullable: true,
+            }),
+            trialUntil: createColumnFilter({
+                expression: SQL.column('member_platform_memberships', 'trialUntil'),
+                type: SQLValueType.Datetime,
+                nullable: true,
+            }),
+            locked: createColumnFilter({
+                expression: SQL.column('member_platform_memberships', 'locked'),
+                type: SQLValueType.Boolean,
+                nullable: false,
+            }),
+            balanceItemId: createColumnFilter({
+                expression: SQL.column('member_platform_memberships', 'balanceItemId'),
+                type: SQLValueType.String,
+                nullable: true,
+            }),
+            generated: createColumnFilter({
+                expression: SQL.column('member_platform_memberships', 'generated'),
+                type: SQLValueType.Boolean,
+                nullable: false,
+            }),
         },
     ),
-    'organizations': createSQLRelationFilterCompiler(
+    'organizations': createExistsFilter(
         SQL.select()
             .from(
                 SQL.table('registrations'),
@@ -277,4 +413,56 @@ export const memberFilterCompilers: SQLFilterDefinitions = {
             ),
         organizationFilterCompilers,
     ),
+    'details': {
+        ...baseSQLFilterCompilers,
+        recordAnswers: createWildcardColumnFilter(
+            (key: string) => ({
+                expression: SQL.jsonValue(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),
+                    type: SQLValueType.JSONBoolean,
+                    nullable: true,
+                }),
+                selectedChoice: {
+                    ...baseSQLFilterCompilers,
+                    id: createColumnFilter({
+                        expression: SQL.jsonValue(SQL.column('details'), `$.value.recordAnswers.${SQLJsonExtract.escapePathComponent(key)}.selectedChoice.id`, true),
+                        type: SQLValueType.JSONString,
+                        nullable: true,
+                    }),
+                },
+                selectedChoices: {
+                    ...baseSQLFilterCompilers,
+                    id: createColumnFilter({
+                        expression: SQL.jsonValue(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),
+                    type: SQLValueType.JSONString,
+                    nullable: true,
+                }),
+            }),
+            {
+                checkPermission: async (key: string) => {
+                    const result = await Context.auth.canFilterMembersOnRecordId(key);
+                    if (!result.canAccess) {
+                        throw new SimpleError({
+                            code: 'permission_denied',
+                            message: 'No permissions for financial support filter (organization scope).',
+                            human: result.record ? $t(`Je hebt niet voldoende toegangsrechten om te filteren op {recordName}`, { recordName: result.record.name }) : $t(`Je hebt niet voldoende toegangsrechten om te filteren op dit gegevensveld`),
+                            statusCode: 400,
+                        });
+                    }
+                },
+            },
+        ),
+    },
 };