@stamhoofd/backend 2.39.1 → 2.40.1

package/src/seeds/1726572303-schedule-stock-updates.ts

@@ -2,13 +2,13 @@ import { Migration } from '@simonbackx/simple-database';
 import { Registration } from '@stamhoofd/models';
 
 export default new Migration(async () => {
-    if (STAMHOOFD.environment == "test") {
-        console.log("skipped in tests")
+    if (STAMHOOFD.environment == 'test') {
+        console.log('skipped in tests');
         return;
     }
 
-    if(STAMHOOFD.userMode !== "platform") {
-        console.log("skipped seed schedule-stock-updates because usermode not platform")
+    if (STAMHOOFD.userMode !== 'platform') {
+        console.log('skipped seed schedule-stock-updates because usermode not platform');
         return;
     }
 
@@ -16,13 +16,13 @@ export default new Migration(async () => {
     let c = 0;
     let id: string = '';
 
-    while(true) {
+    while (true) {
         const rawRegistrations = await Registration.where({
             id: {
                 value: id,
-                sign: '>'
-            }
-        }, {limit: 100, sort: ['id']});
+                sign: '>',
+            },
+        }, { limit: 100, sort: ['id'] });
 
         const registrations = await Registration.getByIDs(...rawRegistrations.map(g => g.id));
 
@@ -31,10 +31,10 @@ export default new Migration(async () => {
 
             c++;
 
-            if (c%1000 === 0) {
+            if (c % 1000 === 0) {
                 process.stdout.write('.');
             }
-            if (c%10000 === 0) {
+            if (c % 10000 === 0) {
                 process.stdout.write('\n');
             }
         }
@@ -47,5 +47,5 @@ export default new Migration(async () => {
     }
 
     // Do something here
-    return Promise.resolve()
-})
+    return Promise.resolve();
+});

package/src/seeds/1726847064-setup-steps.ts

@@ -0,0 +1,16 @@
+import { Migration } from '@simonbackx/simple-database';
+import { SetupStepUpdater } from '@stamhoofd/models';
+
+export default new Migration(async () => {
+    if (STAMHOOFD.environment == 'test') {
+        console.log('skipped in tests');
+        return;
+    }
+
+    if (STAMHOOFD.userMode !== 'platform') {
+        console.log('skipped seed setup-steps because usermode not platform');
+        return;
+    }
+
+    await SetupStepUpdater.updateSetupStepsForAllOrganizationsInCurrentPeriod();
+});

package/src/sql-filters/balance-item-payments.ts

@@ -1,13 +1,13 @@
-import { SQLFilterDefinitions, baseSQLFilterCompilers, createSQLColumnFilterCompiler, SQL, createSQLFilterNamespace } from "@stamhoofd/sql";
+import { SQLFilterDefinitions, baseSQLFilterCompilers, createSQLColumnFilterCompiler, SQL, createSQLFilterNamespace } from '@stamhoofd/sql';
 
 export const balanceItemPaymentsCompilers: SQLFilterDefinitions = {
     ...baseSQLFilterCompilers,
-    "id": createSQLColumnFilterCompiler(SQL.column('balance_item_payments', 'id')),
-    "price": createSQLColumnFilterCompiler(SQL.column('balance_item_payments', 'price')),
-    
-    "balanceItem": createSQLFilterNamespace({
+    id: createSQLColumnFilterCompiler(SQL.column('balance_item_payments', 'id')),
+    price: createSQLColumnFilterCompiler(SQL.column('balance_item_payments', 'price')),
+
+    balanceItem: createSQLFilterNamespace({
         ...baseSQLFilterCompilers,
         id: createSQLColumnFilterCompiler(SQL.column('balance_items', 'id')),
         description: createSQLColumnFilterCompiler(SQL.column('balance_items', 'description')),
-    })
-}
+    }),
+};

package/src/sql-filters/events.ts

@@ -1,26 +1,26 @@
-import { SQLFilterDefinitions, baseSQLFilterCompilers, createSQLColumnFilterCompiler, createSQLExpressionFilterCompiler, SQL, SQLValueType } from "@stamhoofd/sql";
+import { SQLFilterDefinitions, baseSQLFilterCompilers, createSQLColumnFilterCompiler, createSQLExpressionFilterCompiler, SQL, SQLValueType } from '@stamhoofd/sql';
 
 export const eventFilterCompilers: SQLFilterDefinitions = {
     ...baseSQLFilterCompilers,
-    id: createSQLColumnFilterCompiler('id'),
-    name: createSQLColumnFilterCompiler('name'),
-    organizationId: createSQLColumnFilterCompiler('organizationId'),
-    startDate: createSQLColumnFilterCompiler('startDate'),
-    endDate: createSQLColumnFilterCompiler('endDate'),
-    groupIds: createSQLExpressionFilterCompiler(
+    'id': createSQLColumnFilterCompiler('id'),
+    'name': createSQLColumnFilterCompiler('name'),
+    'organizationId': createSQLColumnFilterCompiler('organizationId'),
+    'startDate': createSQLColumnFilterCompiler('startDate'),
+    'endDate': createSQLColumnFilterCompiler('endDate'),
+    'groupIds': createSQLExpressionFilterCompiler(
         SQL.jsonValue(SQL.column('meta'), '$.value.groups[*].id'),
-        {isJSONValue: true, isJSONObject: true}
+        { isJSONValue: true, isJSONObject: true },
     ),
-    defaultAgeGroupIds: createSQLExpressionFilterCompiler(
+    'defaultAgeGroupIds': createSQLExpressionFilterCompiler(
         SQL.jsonValue(SQL.column('meta'), '$.value.defaultAgeGroupIds'),
-        {isJSONValue: true, isJSONObject: true}
+        { isJSONValue: true, isJSONObject: true },
     ),
-    organizationTagIds: createSQLExpressionFilterCompiler(
+    'organizationTagIds': createSQLExpressionFilterCompiler(
         SQL.jsonValue(SQL.column('meta'), '$.value.organizationTagIds'),
-        {isJSONValue: true, isJSONObject: true}
+        { isJSONValue: true, isJSONObject: true },
     ),
     'meta.visible': createSQLExpressionFilterCompiler(
         SQL.jsonValue(SQL.column('meta'), '$.value.visible'),
-        {isJSONValue: true, type: SQLValueType.JSONBoolean}
+        { isJSONValue: true, type: SQLValueType.JSONBoolean },
     ),
-}
+};

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