@stamhoofd/backend 2.14.0 → 2.16.0

package/src/sql-sorters/organizations.ts

@@ -0,0 +1,71 @@
+import { Organization } from "@stamhoofd/models"
+import { SQL, SQLOrderBy, SQLOrderByDirection, SQLSortDefinitions } from "@stamhoofd/sql"
+
+export const organizationSorters: SQLSortDefinitions<Organization> = {
+    'id': {
+        getValue(a) {
+            return a.id
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('id'),
+                direction
+            })
+        }
+    },
+    'name': {
+        getValue(a) {
+            return a.name
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('name'),
+                direction
+            })
+        }
+    },
+    'uri': {
+        getValue(a) {
+            return a.uri
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('uri'),
+                direction
+            })
+        }
+    },
+    'type': {
+        getValue(a) {
+            return a.meta.type
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.jsonValue(SQL.column('meta'), '$.value.type'),
+                direction
+            })
+        }
+    },
+    'city': {
+        getValue(a) {
+            return a.address.city
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.jsonValue(SQL.column('address'), '$.value.city'),
+                direction
+            })
+        }
+    },
+    'country': {
+        getValue(a) {
+            return a.address.country
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.jsonValue(SQL.column('address'), '$.value.country'),
+                direction
+            })
+        }
+    }
+}

package/src/sql-sorters/payments.ts

@@ -0,0 +1,50 @@
+import { Payment } from "@stamhoofd/models"
+import { SQL, SQLOrderBy, SQLOrderByDirection, SQLSortDefinitions } from "@stamhoofd/sql"
+import { Formatter } from "@stamhoofd/utility"
+
+export const paymentSorters: SQLSortDefinitions<Payment> = {
+    'id': {
+        getValue(a) {
+            return a.id
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('id'),
+                direction
+            })
+        }
+    },
+    'createdAt': {
+        getValue(a) {
+            return Formatter.dateTimeIso(a.createdAt, 'UTC')
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('createdAt'),
+                direction
+            })
+        }
+    },
+    'paidAt': {
+        getValue(a) {
+            return a.paidAt !== null ? Formatter.dateTimeIso(a.paidAt, 'UTC') : null
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('paidAt'),
+                direction
+            })
+        }
+    },
+    'price': {
+        getValue(a) {
+            return a.price
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('price'),
+                direction
+            })
+        }
+    }
+}

package/tsconfig.json

@@ -1,6 +1,6 @@
 {
     "compilerOptions": {
-        "target": "es2019", // needs to be es2019 to support optional chaining. Node.js doesn't support optional chaining yet, so we need the transpiling
+        "target": "es2022", // needs to be es2019 to support optional chaining. Node.js doesn't support optional chaining yet, so we need the transpiling
         "module": "commonjs",
         "jsx": "preserve",
         "importHelpers": true,
@@ -14,8 +14,7 @@
         "declarationMap": true,
         "outDir": "dist",
         "lib": [
-            "es2019",
-            "ES2021.String",
+            "es2022",
             "DOM" // axios fix
         ],
         "types": [
@@ -39,4 +38,4 @@
     "ts-node": {
         "files": true
     }
-}
+}

package/src/endpoints/organization/dashboard/payments/legacy/GetPaymentsEndpoint.ts

@@ -1,170 +0,0 @@
-import { AutoEncoder, DateDecoder, EnumDecoder, field, IntegerDecoder, StringDecoder } from "@simonbackx/simple-encoding";
-import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
-import { Organization, Payment } from "@stamhoofd/models";
-import { PaymentGeneral, PaymentMethod, PaymentProvider, PaymentStatus } from "@stamhoofd/structures";
-
-import { StringArrayDecoder } from "../../../../../decoders/StringArrayDecoder";
-import { AuthenticatedStructures } from "../../../../../helpers/AuthenticatedStructures";
-import { Context } from "../../../../../helpers/Context";
-import { StringNullableDecoder } from "../../../../../decoders/StringNullableDecoder";
-
-type Params = Record<string, never>;
-type Body = undefined
-type ResponseBody = PaymentGeneral[]
-
-
-class Query extends AutoEncoder {
-    /**
-     * Usage in combination with paidSince is special!
-     */
-    @field({ decoder: StringDecoder, optional: true })
-    afterId?: string
-
-    /**
-     * Return all payments that were paid after (and including) this date. 
-     * Only returns orders **equal** to this date if afterId is not provided or if the id of those payments is also higher.
-     */
-    @field({ decoder: DateDecoder, optional: true })
-    paidSince?: Date
-
-    @field({ decoder: DateDecoder, optional: true })
-    paidBefore?: Date
-
-    @field({ decoder: IntegerDecoder, optional: true })
-    limit?: number
-
-    @field({ decoder: new StringArrayDecoder(new EnumDecoder(PaymentMethod)), optional: true })
-    methods?: PaymentMethod[]
-
-    @field({ decoder: new StringArrayDecoder(new StringNullableDecoder(new EnumDecoder(PaymentProvider))), optional: true })
-    providers?: (PaymentProvider|null)[]
-}
-
-export class GetPaymentsEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
-    protected queryDecoder = Query;
-
-    protected doesMatch(request: Request): [true, Params] | [false] {
-        if (request.method != "GET") {
-            return [false];
-        }
-
-        const params = Endpoint.parseParameters(request.url, "/organization/payments", {});
-
-        if (params) {
-            return [true, params as Params];
-        }
-        return [false];
-    }
-
-    async handle(request: DecodedRequest<Params, Query, Body>) {
-        const organization = await Context.setOrganizationScope();
-        await Context.authenticate()
-
-        if (!await Context.auth.canManagePayments(organization.id)) {
-            throw Context.auth.error()
-        } 
-
-        return new Response(
-            (await this.getPayments(organization, request.query))
-        );
-    }
-
-    async getPayments(organization: Organization, query: Query) {
-        const paidSince = query.paidSince ?? new Date(Date.now() - (24 * 60 * 60 * 1000 * 7 ))
-        paidSince.setMilliseconds(0)
-        const payments: Payment[] = []
-
-        if (query.afterId) {
-            // First return all payments with id > afterId and paidAt == paidSince
-            payments.push(...await Payment.where({
-                organizationId: organization.id, 
-                paidAt: {
-                    sign: '=', 
-                    value: paidSince
-                },
-                id: {
-                    sign: '>',
-                    value: query.afterId ?? ""
-                },
-                method: {
-                    sign: 'IN', 
-                    value: query.methods ?? [PaymentMethod.Transfer]
-                },
-                provider: {
-                    sign: 'IN', 
-                    value: query.providers ?? [null]
-                }
-            }, {
-                limit: query.limit ?? undefined,
-                sort: [{
-                    column: "id",
-                    direction: "ASC"
-                }]
-            }));
-        }
-
-        payments.push(...await Payment.where({
-            organizationId: organization.id, 
-            paidAt: query.paidBefore ? [{
-                sign: query.afterId  ? '>' : '>=', 
-                value: paidSince
-            }, {
-                sign: '<=', 
-                value: query.paidBefore
-            }] : {
-                sign: query.afterId  ? '>' : '>=', 
-                value: paidSince
-            },
-            method: {
-                sign: 'IN', 
-                value: query.methods ?? [PaymentMethod.Transfer]
-            },
-            provider: {
-                sign: 'IN', 
-                value: query.providers ?? [null]
-            }
-        }, {
-            limit: query.limit ? (query.limit - payments.length) : undefined,
-            sort: [{
-                column: "paidAt",
-                direction: "ASC"
-            }, 
-            {
-                column: "id",
-                direction: "ASC"
-            }]
-        }));
-
-
-        if (!query.paidSince && !query.methods && !query.providers) {
-            // Default behaviour is to return all not-paid transfer payments that are not yet paid
-
-            payments.push(...
-                await Payment.where({
-                    organizationId: organization.id, 
-                    paidAt: null,
-                    method: PaymentMethod.Transfer,
-                    status: {
-                        sign: '!=',
-                        value: PaymentStatus.Failed
-                    }
-                })
-            );
-
-            payments.push(...
-                await Payment.where({
-                    organizationId: organization.id, 
-                    paidAt: null,
-                    updatedAt: {
-                        sign: '>', 
-                        value: new Date(Date.now() - (24 * 60 * 60 * 1000 * 7 ))
-                    },
-                    method: PaymentMethod.Transfer,
-                    status: PaymentStatus.Failed
-                })
-            );
-        }
-
-        return await AuthenticatedStructures.paymentsGeneral(payments, true)
-    }
-}