@stamhoofd/backend 2.39.1 → 2.40.1

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

package/src/sql-filters/registrations.ts

@@ -1,24 +1,24 @@
-import { SQLFilterDefinitions, baseSQLFilterCompilers, createSQLColumnFilterCompiler, SQL, createSQLFilterNamespace, createSQLExpressionFilterCompiler } from "@stamhoofd/sql";
+import { SQLFilterDefinitions, baseSQLFilterCompilers, createSQLColumnFilterCompiler, SQL, createSQLFilterNamespace, createSQLExpressionFilterCompiler } from '@stamhoofd/sql';
 
 export const registrationFilterCompilers: SQLFilterDefinitions = {
     ...baseSQLFilterCompilers,
-    "price": createSQLColumnFilterCompiler('price', {nullable: true}),
-    "pricePaid": createSQLColumnFilterCompiler('pricePaid'),
-    "canRegister": createSQLColumnFilterCompiler('canRegister'),
-    "organizationId": createSQLColumnFilterCompiler('organizationId'),
-    "groupId": createSQLColumnFilterCompiler('groupId'),
-    "registeredAt": createSQLColumnFilterCompiler('registeredAt', {nullable: true}),
-    "periodId": createSQLColumnFilterCompiler(SQL.column('registrations', 'periodId')),
+    price: createSQLColumnFilterCompiler('price', { nullable: true }),
+    pricePaid: createSQLColumnFilterCompiler('pricePaid'),
+    canRegister: createSQLColumnFilterCompiler('canRegister'),
+    organizationId: createSQLColumnFilterCompiler('organizationId'),
+    groupId: createSQLColumnFilterCompiler('groupId'),
+    registeredAt: createSQLColumnFilterCompiler('registeredAt', { nullable: true }),
+    periodId: createSQLColumnFilterCompiler(SQL.column('registrations', 'periodId')),
 
-    "group": createSQLFilterNamespace({
+    group: createSQLFilterNamespace({
         ...baseSQLFilterCompilers,
         id: createSQLColumnFilterCompiler('groupId'),
         name: createSQLExpressionFilterCompiler(
-            SQL.jsonValue(SQL.column('groups', 'settings'), '$.value.name')
+            SQL.jsonValue(SQL.column('groups', 'settings'), '$.value.name'),
         ),
         status: createSQLExpressionFilterCompiler(
-            SQL.column('groups', 'status')
+            SQL.column('groups', 'status'),
         ),
-        defaultAgeGroupId: createSQLColumnFilterCompiler(SQL.column('groups', 'defaultAgeGroupId'), {nullable: true}),
-    })
-}
+        defaultAgeGroupId: createSQLColumnFilterCompiler(SQL.column('groups', 'defaultAgeGroupId'), { nullable: true }),
+    }),
+};

package/src/sql-sorters/events.ts

@@ -1,58 +1,58 @@
-import { Event } from "@stamhoofd/models"
-import { SQL, SQLOrderBy, SQLOrderByDirection, SQLSortDefinitions } from "@stamhoofd/sql"
-import { Formatter } from "@stamhoofd/utility"
+import { Event } from '@stamhoofd/models';
+import { SQL, SQLOrderBy, SQLOrderByDirection, SQLSortDefinitions } from '@stamhoofd/sql';
+import { Formatter } from '@stamhoofd/utility';
 
 export const eventSorters: SQLSortDefinitions<Event> = {
     // 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. 
+    // 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': {
+    id: {
         getValue(a) {
-            return a.id
+            return a.id;
         },
         toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
             return new SQLOrderBy({
                 column: SQL.column('id'),
-                direction
-            })
-        }
+                direction,
+            });
+        },
     },
-    'name': {
+    name: {
         getValue(a) {
-            return a.name
+            return a.name;
         },
         toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
             return new SQLOrderBy({
                 column: SQL.column('name'),
-                direction
-            })
-        }
+                direction,
+            });
+        },
     },
-    'startDate': {
+    startDate: {
         getValue(a) {
-            return Formatter.dateTimeIso(a.startDate)
+            return Formatter.dateTimeIso(a.startDate);
         },
         toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
             return new SQLOrderBy({
                 column: SQL.column('startDate'),
-                direction
-            })
-        }
+                direction,
+            });
+        },
     },
-    'endDate': {
+    endDate: {
         getValue(a) {
-            return Formatter.dateTimeIso(a.endDate)
+            return Formatter.dateTimeIso(a.endDate);
         },
         toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
             return new SQLOrderBy({
                 column: SQL.column('endDate'),
-                direction
-            })
-        }
+                direction,
+            });
+        },
     },
-}
+};

package/src/sql-sorters/members.ts

@@ -1,58 +1,58 @@
-import { MemberWithRegistrations } from "@stamhoofd/models"
-import { SQL, SQLOrderBy, SQLOrderByDirection, SQLSortDefinitions } from "@stamhoofd/sql"
-import { Formatter } from "@stamhoofd/utility"
+import { MemberWithRegistrations } from '@stamhoofd/models';
+import { SQL, SQLOrderBy, SQLOrderByDirection, SQLSortDefinitions } from '@stamhoofd/sql';
+import { Formatter } from '@stamhoofd/utility';
 
 export const memberSorters: SQLSortDefinitions<MemberWithRegistrations> = {
     // 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. 
+    // 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': {
+    id: {
         getValue(a) {
-            return a.id
+            return a.id;
         },
         toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
             return new SQLOrderBy({
                 column: SQL.column('id'),
-                direction
-            })
-        }
+                direction,
+            });
+        },
     },
-    'firstName': {
+    firstName: {
         getValue(a) {
-            return a.firstName
+            return a.firstName;
         },
         toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
             return new SQLOrderBy({
                 column: SQL.column('firstName'),
-                direction
-            })
-        }
+                direction,
+            });
+        },
     },
-    'lastName': {
+    lastName: {
         getValue(a) {
-            return a.lastName
+            return a.lastName;
         },
         toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
             return new SQLOrderBy({
                 column: SQL.column('lastName'),
-                direction
-            })
-        }
+                direction,
+            });
+        },
     },
-    'birthDay': {
+    birthDay: {
         getValue(a) {
-            return a.details.birthDay ? Formatter.dateIso(a.details.birthDay) : null
+            return a.details.birthDay ? Formatter.dateIso(a.details.birthDay) : null;
         },
         toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
             return new SQLOrderBy({
                 column: SQL.column('birthDay'),
-                direction
-            })
-        }
-    }
-}
+                direction,
+            });
+        },
+    },
+};