[int]

misc/conf.example.json

@@ -4,6 +4,21 @@
 		"verbosity": "info",
 		"verification_secret": null
 	},
+	"log": [
+		{
+			"kind": "stdout",
+			"data": {
+				"threshold": "info"
+			}
+		},
+		{
+			"kind": "file",
+			"data": {
+				"threshold": "notice",
+				"path": "/tmp/espe/log.jsonl"
+			}
+		}
+	],
 	"server": {
 		"port": 4916,
 		"path_base": ""
@@ -56,7 +71,12 @@
 			"login_url": null
 		}
 	},
-	"output": {
-		"authelia": "/tmp/authelia-users.yml"
+	"outputs": [
+		{
+			"kind": "authelia_file",
+			"data": {
+				"path": "/tmp/authelia-users.yml"
 			}
 		}
+	]
+}

source/api/actions/invite_accept.ts

@@ -0,0 +1,88 @@
+/*
+Espe | Ein schlichtes Werkzeug zur Mitglieder-Verwaltung | Backend
+Copyright (C) 2024 Christian Fraß
+
+This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public 
+License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later 
+version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied 
+warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with this program. If not, see 
+<https://www.gnu.org/licenses/>. 
+ */
+
+namespace _espe.api
+{
+	/**
+	 */
+	export function register_invite_accept(
+		rest_subject : lib_plankton.rest_http.type_rest
+	) : void
+	{
+		lib_plankton.rest_http.register<
+			{
+				key : string;
+				membership_number_value : (null | string);
+				name_value : string;
+				email_address_value : (null | string);
+				groups_value : Array<string>;
+			},
+			null
+		>(
+			rest_subject,
+			lib_plankton.http.enum_method.post,
+			_espe.api.full_path("/invite/accept"),
+			{
+				/**
+				 * @todo translation
+				 */
+				"description": () => "nimmt eine Einladung an",
+				/**
+				 * @todo
+				 */
+				"input_schema": () => ({
+					"nullable": true,
+				}),
+				/**
+				 * @todo
+				 */
+				"output_schema": () => ({
+					"nullable": true,
+				}),
+				"restriction": () => restriction_none,
+				"execution": () => async ({"input": input}) => {
+					if (input === null) {
+						return Promise.resolve({
+							"status_code": 400,
+							"data": null
+						});
+					}
+					else {
+						try {
+							await _espe.service.invite.accept(
+								input.key,
+								input.membership_number_value,
+								input.name_value,
+								input.email_address_value,
+								input.groups_value
+							);
+							return Promise.resolve({
+								"status_code": 200,
+								"data": null
+							});
+						}
+						catch (error) {
+							return Promise.resolve({
+								"status_code": 404,
+								"data": null
+							});
+						}
+					}
+				}
+			}
+		);
+	}
+	
+}

source/api/actions/invite_create.ts

@@ -0,0 +1,196 @@
+/*
+Espe | Ein schlichtes Werkzeug zur Mitglieder-Verwaltung | Backend
+Copyright (C) 2024 Christian Fraß
+
+This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public 
+License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later 
+version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied 
+warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with this program. If not, see 
+<https://www.gnu.org/licenses/>. 
+ */
+
+namespace _espe.api
+{
+	
+	/**
+	 */
+	export function register_invite_create(
+		rest_subject : lib_plankton.rest_http.type_rest
+	) : void
+	{
+		lib_plankton.rest_http.register<
+			{
+				membership_number_mode : int;
+				membership_number_value : (null | string);
+				name_mode : int;
+				name_value : string;
+				email_address_mode : int;
+				email_address_value : (null | string);
+				groups_mode : int;
+				groups_value : Array<string>;
+				expiry ?: (null | int);
+				// notification_target_url_template ?: (null | string);
+			},
+			(
+				string
+				|
+				{
+					id : _espe.type.member_id;
+					key : string;
+				}
+			)
+		>(
+			rest_subject,
+			lib_plankton.http.enum_method.post,
+			_espe.api.full_path("/invite/create"),
+			{
+				/**
+				 * @todo translation
+				 */
+				"description": () => "erstellt eine Einladung und gibt die erzeugte ID und den erzeugten Schlüssel aus",
+				"input_schema": () => ({
+					"type": "object",
+					"nullable": false,
+					"additionalProperties": false,
+					"properties": {
+						"membership_number_mode": {
+							"type": "integer",
+							"nullable": false,
+							"description": "Mitgliedsnummer | Modus"
+						},
+						"membership_number_value": {
+							"type": "string",
+							"nullable": true,
+							"description": "Mitgliedsnummer | Wert"
+						},
+						"name_mode": {
+							"type": "integer",
+							"nullable": false,
+							"description": "Name | Modus"
+						},
+						"name_value": {
+							"type": "string",
+							"nullable": true,
+							"description": "Name | Wert"
+						},
+						"email_address_mode": {
+							"type": "integer",
+							"nullable": true,
+							"description": "E-Mail-Adresse | Modus"
+						},
+						"email_address_value": {
+							"type": "string",
+							"nullable": true,
+							"description": "E-Mail-Adresse | Wert"
+						},
+						"groups_integer": {
+							"type": "integer",
+							"nullable": true,
+							"description": "Gruppen | Modus"
+						},
+						"groups_value": {
+							"nullable": false,
+							"type": "array",
+							"items": {
+								"type": "string",
+								"nullable": false,
+							},
+							"description": "Gruppen | Wert"
+						},
+						"expiry": {
+							"nullable": true,
+							"type": "intiger",
+							"description": "Ablaufzeitpunkt"
+						},
+						/*
+						"notification_target_url_template": {
+							"type": "string",
+							"nullable": true,
+							"description": "Platz-Halter: id"
+						},
+						 */
+					},
+					"required": [
+						"membership_number_mode",
+						"membership_number_value",
+						"name_mode",
+						"name_value",
+						"email_address_mode",
+						"email_address_value",
+						"groups_mode",
+						"groups_value",
+						"expiry",
+					]
+				}),
+				"output_schema": () => ({
+					"type": "object",
+					"nullable": false,
+					"properties": {
+						"id": {
+							"type": "number",
+							"nullable": false,
+						},
+						"key": {
+							"type": "string",
+							"nullable": false,
+						},
+					},
+					"additionalProperties": false,
+					"required": [
+						"id",
+						"key",
+					]
+				}),
+				"restriction": () => restriction_logged_in,
+				"execution": () => async ({"input": input}) => {
+					if (input === null) {
+						return Promise.reject(new Error("impossible"));
+					}
+					else {
+						if (
+							(! _espe.conf.get().settings.misc.facultative_membership_number)
+							&&
+							(
+								(input.membership_number_value === null)
+								||
+								(input.membership_number_value === "")
+							)
+						) {
+							return Promise.resolve({
+								"status_code": 400,
+								"data": "membership number required"
+							});
+						}
+						else {
+							const invite_info : {id : _espe.type.invite_id; key : _espe.type.invite_key;} = await _espe.service.invite.create(
+								{
+									"membership_number_mode": _espe.helpers.invite_prefill_mode_decode(input.membership_number_mode),
+									"membership_number_value": input.membership_number_value,
+									"name_mode": _espe.helpers.invite_prefill_mode_decode(input.name_mode),
+									"name_value": input.name_value,
+									"email_address_mode": _espe.helpers.invite_prefill_mode_decode(input.email_address_mode),
+									"email_address_value": input.email_address_value,
+									"groups_mode": _espe.helpers.invite_prefill_mode_decode(input.groups_mode),
+									"groups_value": input.groups_value,
+								},
+								{
+									"expiry": input.expiry,
+								}
+							);
+							return Promise.resolve({
+								"status_code": 201,
+								"data": invite_info
+							});
+						}
+					}
+				}
+			}
+		);
+	}
+	
+}
+

source/api/actions/invite_examine.ts

@@ -0,0 +1,165 @@
+/*
+Espe | Ein schlichtes Werkzeug zur Mitglieder-Verwaltung | Backend
+Copyright (C) 2024 Christian Fraß
+
+This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public 
+License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later 
+version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied 
+warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with this program. If not, see 
+<https://www.gnu.org/licenses/>. 
+ */
+
+namespace _espe.api
+{
+	
+	/**
+	 */
+	export function register_invite_examine(
+		rest_subject : lib_plankton.rest_http.type_rest
+	) : void
+	{
+		lib_plankton.rest_http.register<
+			string,
+			(
+				{
+					expiry : (null | int);
+					membership_number_mode : int;
+					membership_number_value : (null | string);
+					name_mode : int;
+					name_value : string;
+					email_address_mode : int;
+					email_address_value : (null | string);
+					groups_mode : int;
+					groups_value : Array<string>;
+				}
+				|
+				null
+				|
+				string
+			)
+		>(
+			rest_subject,
+			lib_plankton.http.enum_method.get,
+			_espe.api.full_path("/invite/examine"),
+			{
+				/**
+				 * @todo translation
+				 */
+				"description": () => "gibt die Daten einer Einladung anhand ihres Schlüssels aus",
+				"input_schema": () => ({
+					"type": "string",
+					"nullable": false,
+				}),
+				"output_schema": () => ({
+					"type": "object",
+					"nullable": false,
+					"additionalProperties": false,
+					"properties": {
+						"expiry": {
+							"nullable": true,
+							"type": "intiger",
+							"description": "Ablaufzeitpunkt"
+						},
+						"membership_number_mode": {
+							"type": "integer",
+							"nullable": false,
+							"description": "Mitgliedsnummer | Modus"
+						},
+						"membership_number_value": {
+							"type": "string",
+							"nullable": true,
+							"description": "Mitgliedsnummer | Wert"
+						},
+						"name_mode": {
+							"type": "integer",
+							"nullable": false,
+							"description": "Name | Modus"
+						},
+						"name_value": {
+							"type": "string",
+							"nullable": true,
+							"description": "Name | Wert"
+						},
+						"email_address_mode": {
+							"type": "integer",
+							"nullable": true,
+							"description": "E-Mail-Adresse | Modus"
+						},
+						"email_address_value": {
+							"type": "string",
+							"nullable": true,
+							"description": "E-Mail-Adresse | Wert"
+						},
+						"groups_integer": {
+							"type": "integer",
+							"nullable": true,
+							"description": "Gruppen | Modus"
+						},
+						"groups_value": {
+							"nullable": false,
+							"type": "array",
+							"items": {
+								"type": "string",
+								"nullable": false,
+							},
+							"description": "Gruppen | Wert"
+						},
+					},
+					"required": [
+						"expiry",
+						"membership_number_mode",
+						"membership_number_value",
+						"name_mode",
+						"name_value",
+						"email_address_mode",
+						"email_address_value",
+						"groups_mode",
+						"groups_value",
+					]
+				}),
+				"restriction": () => restriction_none,
+				"execution": () => ({"input": input}) => {
+					if (input === null) {
+						return Promise.resolve({"status_code": 500, "data": null});
+					}
+					else {
+						const invite_key : _espe.type.invite_key = input;
+						return (
+							_espe.service.invite.examine(invite_key)
+							.then(
+								(invite_object) => Promise.resolve({
+									"status_code": 200,
+									"data": {
+										"expiry": invite_object.expiry,
+										"membership_number_mode": _espe.helpers.invite_prefill_mode_encode(invite_object.membership_number_mode),
+										"membership_number_value": invite_object.membership_number_value,
+										"name_mode": _espe.helpers.invite_prefill_mode_encode(invite_object.name_mode),
+										"name_value": invite_object.name_value,
+										"email_address_mode": _espe.helpers.invite_prefill_mode_encode(invite_object.email_address_mode),
+										"email_address_value": invite_object.email_address_value,
+										"groups_mode": _espe.helpers.invite_prefill_mode_encode(invite_object.groups_mode),
+										"groups_value": invite_object.groups_value,
+									}
+								})
+							)
+							.catch(
+								/**
+								 * in order to give less information to potentiall attackers, we treat all fails as "not found"
+								 */
+								(error) => Promise.resolve({
+									"status_code": 404,
+									"data": "not found"
+								})
+							)
+						);
+					}
+				}
+			}
+		);
+	}
+	
+}

source/api/actions/member_delete.ts

@@ -19,17 +19,20 @@ namespace _espe.api
 	/**
 	 */
 	export function register_member_delete(
-		rest_subject : lib_plankton.rest.type_rest
+		rest_subject : lib_plankton.rest_http.type_rest
 	) : void
 	{
-		register<null, null>(
+		lib_plankton.rest_http.register<
+			null,
+			null
+		>(
 			rest_subject,
 			lib_plankton.http.enum_method.delete,
-			"/member/delete/:id",
+			_espe.api.full_path("/member/delete/:id"),
 			{
-				"description": "löscht ein vorhandenes Mitglied",
-				"restriction": restriction_logged_in,
-				"execution": async ({"path_parameters": path_parameters}) => {
+				"description": () => "löscht ein vorhandenes Mitglied",
+				"restriction": () => restriction_logged_in,
+				"execution": () => async ({"path_parameters": path_parameters}) => {
 					const member_id : _espe.type.member_id = parseInt(path_parameters["id"]);
 					await _espe.service.member.remove(member_id);
 					return Promise.resolve({

source/api/actions/member_info.ts

@@ -20,10 +20,10 @@ namespace _espe.api
 	 * @todo zeitliche Begrenzung?
 	 */
 	export function register_member_info(
-		rest_subject : lib_plankton.rest.type_rest
+		rest_subject : lib_plankton.rest_http.type_rest
 	) : void
 	{
-		register<
+		lib_plankton.rest_http.register<
 			int,
 			(
 				null
@@ -39,9 +39,9 @@ namespace _espe.api
 		>(
 			rest_subject,
 			lib_plankton.http.enum_method.get,
-			"/member/info/:id",
+			_espe.api.full_path("/member/info/:id"),
 			{
-				"description": "gibt Angaben über ein Mitglied aus, die für die Registrierung verwendet werden dürfen",
+				"description": () => "gibt Angaben über ein Mitglied aus, die für die Registrierung verwendet werden dürfen",
 				"input_schema": () => ({
 					"type": "number",
 					"nullable": false,
@@ -80,18 +80,18 @@ namespace _espe.api
 						"email_address_nominal",
 					]
 				}),
-				"query_parameters": [
+				"query_parameters": () => [
 					{
 						"name": "key",
 						"required": true,
 						"description": "Zugriffs-Schlüssel",
 					},
 				],
-				"restriction": restriction_verification(
+				"restriction": () => restriction_verification(
 					stuff => parseInt(stuff.path_parameters["id"]),
 					stuff => stuff.query_parameters["key"]
 				),
-				"execution": async ({"path_parameters": path_parameters, "input": input}) => {
+				"execution": () => async ({"path_parameters": path_parameters, "input": input}) => {
 					const member_id : _espe.type.member_id = parseInt(path_parameters["id"]);
 					const data : (
 						null

source/api/actions/member_list.ts

@@ -19,10 +19,10 @@ namespace _espe.api
 	/**
 	 */
 	export function register_member_list(
-		rest_subject : lib_plankton.rest.type_rest
+		rest_subject : lib_plankton.rest_http.type_rest
 	) : void
 	{
-		register<
+		lib_plankton.rest_http.register<
 			null,
 			Array<
 				{
@@ -37,10 +37,10 @@ namespace _espe.api
 		>(
 			rest_subject,
 			lib_plankton.http.enum_method.get,
-			"/member/list",
+			_espe.api.full_path("/member/list"),
 			{
-				"description": "listet alle Mitglieder auf",
-				"query_parameters": [
+				"description": () => "listet alle Mitglieder auf",
+				"query_parameters": () => [
 					{
 						"name": "search_term",
 						"required": false,
@@ -88,8 +88,8 @@ namespace _espe.api
 						],
 					}
 				}),
-				"restriction": restriction_logged_in,
-				"execution": ({"query_parameters": query_parameters}) => (
+				"restriction": () => restriction_logged_in,
+				"execution": () => ({"query_parameters": query_parameters}) => (
 					_espe.service.member.list(query_parameters["search_term"] ?? null)
 					.then(
 						data => Promise.resolve({

source/api/actions/member_modify.ts

@@ -19,10 +19,10 @@ namespace _espe.api
 	/**
 	 */
 	export function register_member_modify(
-		rest_subject : lib_plankton.rest.type_rest
+		rest_subject : lib_plankton.rest_http.type_rest
 	) : void
 	{
-		register<
+		lib_plankton.rest_http.register<
 			{
 				email_address_private : (null | string);
 				groups ?: Array<string>;
@@ -33,9 +33,9 @@ namespace _espe.api
 		>(
 			rest_subject,
 			lib_plankton.http.enum_method.patch,
-			"/member/modify/:id",
+			_espe.api.full_path("/member/modify/:id"),
 			{
-				"description": "ändert die Angaben eines vorhandenen Mitglieds",
+				"description": () => "ändert die Angaben eines vorhandenen Mitglieds",
 				"input_schema": () => ({
 					"nullable": false,
 					"type": "object",
@@ -71,8 +71,8 @@ namespace _espe.api
 				"output_schema": () => ({
 					"nullable": true,
 				}),
-				"restriction": restriction_logged_in,
-				"execution": async ({"path_parameters": path_parameters, "input": input}) => {
+				"restriction": () => restriction_logged_in,
+				"execution": () => async ({"path_parameters": path_parameters, "input": input}) => {
 					if (input === null) {
 						return Promise.reject(new Error("impossible"));
 					}

source/api/actions/member_password_change_execute.ts

@@ -20,10 +20,10 @@ namespace _espe.api
 	 * @todo ausgeklügelte Durchsatzratenbegrenzung
 	 */
 	export function register_member_password_change_execute(
-		rest_subject : lib_plankton.rest.type_rest
+		rest_subject : lib_plankton.rest_http.type_rest
 	) : void
 	{
-		register<
+		lib_plankton.rest_http.register<
 			{
 				token : string;
 				password_new : string;
@@ -37,9 +37,9 @@ namespace _espe.api
 		>(
 			rest_subject,
 			lib_plankton.http.enum_method.patch,
-			"/member/password_change/execute/:id",
+			_espe.api.full_path("/member/password_change/execute/:id"),
 			{
-				"description": "Führt eine Passwort-Änderung für ein Mitglied durch",
+				"description": () => "Führt eine Passwort-Änderung für ein Mitglied durch",
 				"input_schema": () => ({
 					"nullable": false,
 					"type": "object",
@@ -88,8 +88,8 @@ namespace _espe.api
 						]
 					}
 				}),
-				"restriction": restriction_none,
-				"execution": ({"path_parameters": path_parameters, "input": input}) => {
+				"restriction": () => restriction_none,
+				"execution": () => ({"path_parameters": path_parameters, "input": input}) => {
 					if (input === null) {
 						return Promise.reject(new Error("impossible"));
 					}

source/api/actions/member_password_change_initialize.ts

@@ -21,10 +21,10 @@ namespace _espe.api
 	 * @todo captcha
 	 */
 	export function register_member_password_change_initialize(
-		rest_subject : lib_plankton.rest.type_rest
+		rest_subject : lib_plankton.rest_http.type_rest
 	) : void
 	{
-		register<
+		lib_plankton.rest_http.register<
 			{
 				identifier : string;
 				url_template : string;
@@ -33,9 +33,9 @@ namespace _espe.api
 		>(
 			rest_subject,
 			lib_plankton.http.enum_method.post,
-			"/member/password_change/initialize",
+			_espe.api.full_path("/member/password_change/initialize"),
 			{
-				"description": "Versucht dem gegebenen Identifikator ein Mitglied zuzuordnen und sendet dem ermittelten Mitglied einen Passwort-Änderungs-Verweis an die hinterlegte private E-Mail-Adresse",
+				"description": () => "Versucht dem gegebenen Identifikator ein Mitglied zuzuordnen und sendet dem ermittelten Mitglied einen Passwort-Änderungs-Verweis an die hinterlegte private E-Mail-Adresse",
 				"input_schema": () => ({
 					"nullable": false,
 					"type": "object",
@@ -60,8 +60,8 @@ namespace _espe.api
 				"output_schema": () => ({
 					"nullable": true
 				}),
-				"restriction": restriction_none,
-				"execution": async ({"input": input}) => {
+				"restriction": () => restriction_none,
+				"execution": () => async ({"input": input}) => {
 					if (input === null) {
 						return Promise.reject(new Error("impossible"));
 					}

source/api/actions/member_project.ts

@@ -19,10 +19,10 @@ namespace _espe.api
 	/**
 	 */
 	export function register_member_project(
-		rest_subject : lib_plankton.rest.type_rest
+		rest_subject : lib_plankton.rest_http.type_rest
 	) : void
 	{
-		register<
+		lib_plankton.rest_http.register<
 			{
 				membership_number : (null | string);
 				name_real_value : string;
@@ -38,9 +38,9 @@ namespace _espe.api
 		>(
 			rest_subject,
 			lib_plankton.http.enum_method.post,
-			"/member/project",
+			_espe.api.full_path("/member/project"),
 			{
-				"description": "erstellt ein neues Mitglied und gibt die erzeugte ID aus",
+				"description": () => "erstellt ein neues Mitglied und gibt die erzeugte ID aus",
 				"input_schema": () => ({
 					"type": "object",
 					"nullable": false,
@@ -84,8 +84,8 @@ namespace _espe.api
 					"type": "number",
 					"nullable": false,
 				}),
-				"restriction": restriction_logged_in,
-				"execution": async ({"input": input}) => {
+				"restriction": () => restriction_logged_in,
+				"execution": () => async ({"input": input}) => {
 					if (input === null) {
 						return Promise.reject(new Error("impossible"));
 					}

source/api/actions/member_read.ts

@@ -19,10 +19,10 @@ namespace _espe.api
 	/**
 	 */
 	export function register_member_read(
-		rest_subject : lib_plankton.rest.type_rest
+		rest_subject : lib_plankton.rest_http.type_rest
 	) : void
 	{
-		register<
+		lib_plankton.rest_http.register<
 			null,
 			{
 				membership_number : (null | string);
@@ -44,9 +44,9 @@ namespace _espe.api
 		>(
 			rest_subject,
 			lib_plankton.http.enum_method.get,
-			"/member/read/:id",
+			_espe.api.full_path("/member/read/:id"),
 			{
-				"description": "gibt ein Mitglied anhand seiner ID aus",
+				"description": () => "gibt ein Mitglied anhand seiner ID aus",
 				"output_schema": () => ({
 					"nullable": false,
 					"type": "object",
@@ -135,8 +135,8 @@ namespace _espe.api
 						"name_login",
 					]
 				}),
-				"restriction": restriction_logged_in,
-				"execution": async ({"path_parameters": path_parameters, "input": input}) => {
+				"restriction": () => restriction_logged_in,
+				"execution": () => async ({"path_parameters": path_parameters, "input": input}) => {
 					const member_id : _espe.type.member_id = parseInt(path_parameters["id"]);
 					const member_object : _espe.type.member_object = await _espe.service.member.get(member_id);
 					return Promise.resolve({

source/api/actions/member_register.ts

@@ -20,10 +20,10 @@ namespace _espe.api
 	 * @todo zeitliche Begrenzung?
 	 */
 	export function register_member_register(
-		rest_subject : lib_plankton.rest.type_rest
+		rest_subject : lib_plankton.rest_http.type_rest
 	) : void
 	{
-		register<
+		lib_plankton.rest_http.register<
 			{
 				email_use_veiled_address : boolean;
 				email_use_nominal_address : boolean;
@@ -40,9 +40,9 @@ namespace _espe.api
 		>(
 			rest_subject,
 			lib_plankton.http.enum_method.post,
-			"/member/register/:id",
+			_espe.api.full_path("/member/register/:id"),
 			{
-				"description": "nimmt zusätzliche Angaben eines Mitglieds entgegen",
+				"description": () => "nimmt zusätzliche Angaben eines Mitglieds entgegen",
 				"input_schema": () => ({
 					"type": "object",
 					"nullable": false,
@@ -109,18 +109,18 @@ namespace _espe.api
 						]
 					}
 				}),
-				"query_parameters": [
+				"query_parameters": () => [
 					{
 						"name": "key",
 						"required": true,
 						"description": "Zugriffs-Schlüssel",
 					},
 				],
-				"restriction": restriction_verification(
+				"restriction": () => restriction_verification(
 					stuff => parseInt(stuff.path_parameters["id"]),
 					stuff => stuff.query_parameters["key"]
 				),
-				"execution": ({"path_parameters": path_parameters, "input": input}) => {
+				"execution": () => ({"path_parameters": path_parameters, "input": input}) => {
 					if (input === null) {
 						return Promise.reject(new Error("impossible"));
 					}

source/api/actions/member_summon.ts

@@ -19,10 +19,10 @@ namespace _espe.api
 	/**
 	 */
 	export function register_member_summon(
-		rest_subject : lib_plankton.rest.type_rest
+		rest_subject : lib_plankton.rest_http.type_rest
 	) : void
 	{
-		lib_plankton.rest.register<
+		lib_plankton.rest_http.register<
 			{
 				url_template : string;
 			},
@@ -36,9 +36,9 @@ namespace _espe.api
 			lib_plankton.http.enum_method.post,
 			_espe.conf.get().server.path_base + "/member/summon/:id",
 			{
-				"description": "sendet an ein Mitglied eine E-Mail mit Aufforderung zur Registrierung",
-				"restriction": restriction_logged_in,
-				"execution": async ({"path_parameters": path_parameters, "input": input}) => {
+				"description": () => "sendet an ein Mitglied eine E-Mail mit Aufforderung zur Registrierung",
+				"restriction": () => restriction_logged_in,
+				"execution": () => async ({"path_parameters": path_parameters, "input": input}) => {
 					if (input === null) {
 						return Promise.reject(new Error("impossible"));
 					}

source/api/actions/meta_ping.ts

@@ -19,10 +19,10 @@ namespace _espe.api
 	/**
 	 */
 	export function register_meta_ping(
-		rest_subject : lib_plankton.rest.type_rest
+		rest_subject : lib_plankton.rest_http.type_rest
 	) : void
 	{
-		lib_plankton.rest.register<
+		lib_plankton.rest_http.register<
 			null,
 			string
 		>
@@ -31,7 +31,7 @@ namespace _espe.api
 			lib_plankton.http.enum_method.get,
 			_espe.conf.get().server.path_base + "/meta/ping",
 			{
-				"description": "sendet ein 'pong' zurück; gedacht um die Erreichbarkeit des Backends zu prüfen",
+				"description": () => "sendet ein 'pong' zurück; gedacht um die Erreichbarkeit des Backends zu prüfen",
 				"input_schema": () => ({
 					"nullable": true,
 				}),
@@ -39,8 +39,8 @@ namespace _espe.api
 					"nullable": false,
 					"type": "string",
 				}),
-				"restriction": restriction_none,
-				"execution": () => {
+				"restriction": () => restriction_none,
+				"execution": () => () => {
 					return Promise.resolve({
 						"status_code": 200,
 						"data": "pong",

source/api/actions/meta_spec.ts

@@ -19,10 +19,10 @@ namespace _espe.api
 	/**
 	 */
 	export function register_meta_spec(
-		rest_subject : lib_plankton.rest.type_rest
+		rest_subject : lib_plankton.rest_http.type_rest
 	) : void
 	{
-		lib_plankton.rest.register<
+		lib_plankton.rest_http.register<
 			null,
 			any
 		>
@@ -31,17 +31,17 @@ namespace _espe.api
 			lib_plankton.http.enum_method.get,
 			_espe.conf.get().server.path_base + "/meta/spec",
 			{
-				"description": "gibt die API-Spezifikation im OpenAPI-Format aus",
+				"description": () => "gibt die API-Spezifikation im OpenAPI-Format aus",
 				"input_schema": () => ({
 					"nullable": true,
 				}),
 				"output_schema": () => ({
 				}),
-				"restriction": restriction_none,
-				"execution": () => {
+				"restriction": () => restriction_none,
+				"execution": () => () => {
 					return Promise.resolve({
 						"status_code": 200,
-						"data": lib_plankton.rest.to_oas(rest_subject),
+						"data": lib_plankton.rest_http.to_oas(rest_subject),
 					});
 				},
 			}

source/api/actions/session_begin.ts

@@ -19,10 +19,10 @@ namespace _espe.api
 	/**
 	 */
 	export function register_session_begin(
-		rest_subject : lib_plankton.rest.type_rest
+		rest_subject : lib_plankton.rest_http.type_rest
 	) : void
 	{
-		lib_plankton.rest.register<
+		lib_plankton.rest_http.register<
 			{
 				name : string;
 				password : string;
@@ -37,7 +37,7 @@ namespace _espe.api
 			lib_plankton.http.enum_method.post,
 			_espe.conf.get().server.path_base + "/session/begin",
 			{
-				"description": "führt die Anmeldung am System aus um geschützte Aktionen nutzen zu können",
+				"description": () => "führt die Anmeldung am System aus um geschützte Aktionen nutzen zu können",
 				"input_schema": () => ({
 					"type": "object",
 					"properties": {
@@ -58,8 +58,8 @@ namespace _espe.api
 					"type": "string",
 					"description": "der Sitzungs-Schlüssel, der als Header 'X-Session-Key' gesetzt werden muss um Erlaubnis zur Ausführung geschützter Aktionen zu erhalten",
 				}),
-				"restriction": restriction_none,
-				"execution": async ({"input": input}) => {
+				"restriction": () => restriction_none,
+				"execution": () => async ({"input": input}) => {
 					if (input === null) {
 						return Promise.reject(new Error("impossible"));
 					}

source/api/actions/session_end.ts

@@ -19,23 +19,26 @@ namespace _espe.api
 	/**
 	 */
 	export function register_session_end(
-		rest_subject : lib_plankton.rest.type_rest
+		rest_subject : lib_plankton.rest_http.type_rest
 	) : void
 	{
-		register<null, null>(
+		lib_plankton.rest_http.register<
+			null,
+			null
+		>(
 			rest_subject,
 			lib_plankton.http.enum_method.delete,
 			"/session/end",
 			{
-				"description": "beendet eine Sitzung",
+				"description": () => "beendet eine Sitzung",
 				"input_schema": () => ({
 					"type": "null",
 				}),
 				"output_schema": () => ({
 					"type": "null",
 				}),
-				"restriction": restriction_logged_in,
-				"execution": async (stuff) => {
+				"restriction": () => restriction_logged_in,
+				"execution": () => async (stuff) => {
 					const session : {key : string; value : lib_plankton.session.type_session} = await session_from_stuff(stuff);
 					await lib_plankton.session.end(session.key);
 					return Promise.resolve({

source/api/base.ts

@@ -20,7 +20,7 @@ namespace _espe.api
 	 * @todo zu plankton auslagern?
 	 */
 	type type_stuff = {
-        version: (null | string);
+        // version: (null | string);
         headers: Record<string, string>;
         path_parameters: Record<string, string>;
         query_parameters: Record<string, string>;
@@ -43,9 +43,9 @@ namespace _espe.api
 	 */
 	/*
 	export function restriction_disjunction(
-		left : lib_plankton.rest.type_restriction<any>,
-		right : lib_plankton.rest.type_restriction<any>
-	) : lib_plankton.rest.type_restriction<any>
+		left : lib_plankton.rest_http.type_restriction<any>,
+		right : lib_plankton.rest_http.type_restriction<any>
+	) : lib_plankton.rest_http.type_restriction<any>
 	{
 		return (
 			(stuff) => Promise.any<boolean>(
@@ -61,14 +61,14 @@ namespace _espe.api
 	
 	/**
 	 */
-	export const restriction_none : lib_plankton.rest.type_restriction<any> = (
+	export const restriction_none : lib_plankton.rest_http.type_restriction<any> = (
 		(stuff) => Promise.resolve<boolean>(true)
 	);
 	
 	
 	/**
 	 */
-	export const restriction_logged_in : lib_plankton.rest.type_restriction<any> = (
+	export const restriction_logged_in : lib_plankton.rest_http.type_restriction<any> = (
 		(stuff) => (
 			session_from_stuff(stuff)
 			.then(() => Promise.resolve<boolean>(true))
@@ -82,7 +82,7 @@ namespace _espe.api
 	export function restriction_verification(
 		extract_data : ((stuff : type_stuff) => any),
 		extract_verification : ((stuff : type_stuff) => string)
-	) : lib_plankton.rest.type_restriction<any>
+	) : lib_plankton.rest_http.type_restriction<any>
 	{
 		return (
 			(stuff) => _espe.helpers.verification_check(
@@ -92,17 +92,27 @@ namespace _espe.api
 		);
 	}
 	
+	/**
+	 */
+	export function full_path(
+		path : string
+	) : string
+	{
+		return (_espe.conf.get().server.path_base + path);
+	}
+
 	
 	/**
 	 */
+	/*
 	export function register<type_input, type_output>(
-		rest_subject : lib_plankton.rest.type_rest,
+		rest_subject : lib_plankton.rest_http.type_rest,
 		http_method : lib_plankton.http.enum_method,
 		path : string,
 		options : {
-			active ?: ((version : string) => boolean);
-			restriction ?: (null | lib_plankton.rest.type_restriction<type_input>);
-			execution ?: lib_plankton.rest.type_execution<type_input, type_output>;
+			active ?: ((version : (null | string)) => boolean);
+			restriction ?: (null | lib_plankton.rest_http.type_restriction<type_input>);
+			execution ?: lib_plankton.rest_http.type_execution<type_input, type_output>;
 			title ?: (null | string);
 			description ?: (null | string);
 			query_parameters ?: Array<
@@ -112,8 +122,8 @@ namespace _espe.api
 					required : boolean;
 				}
 			>;
-			input_schema ?: ((version: (null | string)) => lib_plankton.rest.type_oas_schema);
-			output_schema ?: ((version: (null | string)) => lib_plankton.rest.type_oas_schema);
+			input_schema ?: ((version: (null | string)) => lib_plankton.rest_http.type_oas_schema);
+			output_schema ?: ((version: (null | string)) => lib_plankton.rest_http.type_oas_schema);
 			request_body_mimetype ?: string;
 			request_body_decode ?: ((http_request_body : Buffer, http_request_header_content_type : (null | string)) => any);
 			response_body_mimetype ?: string;
@@ -121,17 +131,12 @@ namespace _espe.api
 		} = {}
 	) : void
 	{
-		options = Object.assign(
-			{
-			},
-			options
-		);
-		lib_plankton.rest.register<type_input, type_output>(
+		lib_plankton.rest_http.register<type_input, type_output>(
 			rest_subject,
 			http_method,
 			(_espe.conf.get().server.path_base + path),
 			options
 		);
 	}
-	
+	 */
 }

source/api/functions.ts

@@ -19,9 +19,9 @@ namespace _espe.api
 	/**
 	 */
 	export function make(
-	) : lib_plankton.rest.type_rest
+	) : lib_plankton.rest_http.type_rest
 	{
-		const rest_subject : lib_plankton.rest.type_rest = lib_plankton.rest.make(
+		const rest_subject : lib_plankton.rest_http.type_rest = lib_plankton.rest_http.make(
 			{
 				"title": "espe",
 				"versioning_method": "header",
@@ -29,7 +29,7 @@ namespace _espe.api
 				"set_access_control_headers": true,
 				"authentication": {
 					"kind": "key_header",
-					"parameters": {"name": "X-Session-Key"}
+					"data": {"name": "X-Session-Key"}
 				},
 			}
 		);
@@ -59,7 +59,12 @@ namespace _espe.api
 				_espe.api.register_member_password_change_execute(rest_subject);
 			}
 		}
-		
+		// invite
+		{
+			_espe.api.register_invite_create(rest_subject);
+			_espe.api.register_invite_examine(rest_subject);
+			_espe.api.register_invite_accept(rest_subject);
+		}
 		
 		return rest_subject;
 	}

source/conf.ts

@@ -42,12 +42,7 @@ namespace _espe.conf
 	
 	/**
 	 */
-	export type type_conf = {
-		general : {
-			language : (null | string);
-			verification_secret : (null | string);
-		};
-		log : Array<
+	export type type_log_channel = (
 		{
 			kind : "stdout";
 			data : {
@@ -77,6 +72,18 @@ namespace _espe.conf
 				receivers : Array<string>;
 			};
 		}
+	);
+	
+	
+	/**
+	 */
+	export type type_conf = {
+		general : {
+			language : (null | string);
+			verification_secret : (null | string);
+		};
+		log : Array<
+			type_log_channel
 		>;
 		server : {
 			host : string;
@@ -454,7 +461,8 @@ namespace _espe.conf
 						return (conf_raw["outputs"] ?? []);
 						break;
 					}
-					case 4: {
+					case 4:
+					case 5: {
 						const node_outputs = (conf_raw["outputs"] ?? []);
 						return node_outputs.map(
 							(output_description : {kind : string; data : any;}) => {

source/database.ts

@@ -19,7 +19,7 @@ namespace _espe.database
 	/**
 	 */
 	const _compatible_revisions : Array<string> = [
-		"r6",
+		"r7",
 	];
 	
 		

source/helpers.ts

@@ -248,4 +248,34 @@ namespace _espe.helpers
 		}
 	}
 	
+	
+	/**
+	 */
+	export function invite_prefill_mode_encode(
+		invite_prefill_mode : _espe.type.invite_prefill_mode
+	) : int
+	{
+		switch (invite_prefill_mode) {
+			case _espe.type.invite_prefill_mode.hidden: return 0;
+			case _espe.type.invite_prefill_mode.locked: return 1;
+			case _espe.type.invite_prefill_mode.free: return 2;
+			default: throw (new Error("unhandled invite prefill mode: " + String(invite_prefill_mode)));
+		}
+	}
+	
+	
+	/**
+	 */
+	export function invite_prefill_mode_decode(
+		invite_prefill_mode_encoded : int
+	) : _espe.type.invite_prefill_mode
+	{
+		switch (invite_prefill_mode_encoded) {
+			case 0: return _espe.type.invite_prefill_mode.hidden;
+			case 1: return _espe.type.invite_prefill_mode.locked;
+			case 2: return _espe.type.invite_prefill_mode.free;
+			default: throw (new Error("unhandled encoded invite prefill mode: " + String(invite_prefill_mode_encoded)));
+		}
+	}
+	
 }

source/main.ts

@@ -13,27 +13,131 @@ You should have received a copy of the GNU General Public License along with thi
 <https://www.gnu.org/licenses/>. 
  */
 
+namespace _espe
+{
 	
 	/**
 	 */
-async function main(
+	function setup_log_fallback(
+	) : void
+	{
+		lib_plankton.log.set_main_logger(
+			[
+				{
+					"kind": "filtered",
+					"data": {
+						"core": {
+							"kind": "std",
+							"data": {
+								"target": "stdout",
+								"format": {
+									"kind": "human_readable",
+									"data": {}
+								}
+							}
+						},
+						"predicate": [
+							[
+								{
+									"item": {
+										"kind": "level",
+										"data": {"threshold": "info"}
+									},
+								}
+							]
+						],
+					}
+				},
+			]
+		);
+	}
+	
+	
+	/**
+	 */
+	function setup_log_from_conf(
+	) : void
+	{
+		lib_plankton.log.set_main_logger(
+			_espe.conf.get().log.map(
+				log_channel => {
+					switch (log_channel.kind) {
+						case "stdout": {
+							return {
+								"kind": "filtered",
+								"data": {
+									"core": {
+										"kind": "std",
+										"data": {
+											"target": "stdout",
+											"format": {"kind": "human_readable", "data": {}}
+										}
+									},
+									"predicate": [
+										[
+											{"item": {"kind": "level", "data": {"threshold": log_channel.data.threshold}}}
+										]
+									],
+								}
+							};
+							break;
+						}
+						case "file": {
+							return {
+								"kind": "filtered",
+								"data": {
+									"core": {
+										"kind": "file",
+										"data": {
+											"path": log_channel.data.path,
+											"format": {"kind": "jsonl", "data": {"structured": false}}
+										}
+									},
+									"predicate": [
+										[
+											{"item": {"kind": "level", "data": {"threshold": log_channel.data.threshold}}}
+										]
+									],
+								}
+							};
+							break;
+						}
+						case "email": {
+							return {
+								"kind": "filtered",
+								"data": {
+									"core": {
+										"kind": "email",
+										"data": log_channel.data
+									},
+									"predicate": [
+										[
+											{"item": {"kind": "level", "data": {"threshold": log_channel.data.threshold}}}
+										]
+									],
+								}
+							};
+							break;
+						}
+						default: {
+							throw (new Error("unhandled log channel"));
+							break;
+						}
+					}
+				}
+			)
+		);
+	}
+
+
+	/**
+	 */
+	export async function main(
 		args_raw : Array<string>
 	) : Promise<void>
 	{
 		// init
-	lib_plankton.log.conf_push(
-		[
-			lib_plankton.log.channel_make(
-				{
-					"kind": "stdout",
-					"data": {
-						"threshold": "notice",
-						// "format": "human_readable",
-					}
-				}
-			),
-		]
-	);
+		setup_log_fallback();
 		const language_codes : Array<string> = [
 			"deu",
 			"eng",
@@ -198,16 +302,7 @@ async function main(
 				lib_plankton.translate.promote(language);
 			}
 		}
-	lib_plankton.log.conf_push(
-		_espe.conf.get().log.map(
-			log_output => lib_plankton.log.channel_make(
-				{
-					"kind": log_output.kind,
-					"data": log_output.data
-				}
-			)
-		)
-	);
+		setup_log_from_conf();
 		
 		// exec
 		if (args["help"] || (args["action"] === "help")) {
@@ -253,12 +348,12 @@ async function main(
 					break;
 				}
 				case "api-doc": {
-				lib_plankton.log.conf_push([]);
-				const rest_subject : lib_plankton.rest.type_rest = _espe.api.make();
-				lib_plankton.log.conf_pop();
+					// lib_plankton.log.conf_push([]);
+					const rest_subject : lib_plankton.rest_http.type_rest = _espe.api.make();
+					// lib_plankton.log.conf_pop();
 					process.stdout.write(
 						JSON.stringify(
-						lib_plankton.rest.to_oas(rest_subject),
+							lib_plankton.rest_http.to_oas(rest_subject),
 							undefined,
 							"\t"
 						)
@@ -393,11 +488,11 @@ async function main(
 						}
 					);
 					
-				const rest_subject : lib_plankton.rest.type_rest = _espe.api.make();
+					const rest_subject : lib_plankton.rest_http.type_rest = _espe.api.make();
 					const server : lib_plankton.server.type_subject = lib_plankton.server.make(
 						async (input, metadata) => {
 							const http_request : lib_plankton.http.type_request = lib_plankton.http.decode_request(input.toString());
-						const http_response : lib_plankton.http.type_response = await lib_plankton.rest.call(
+							const http_response : lib_plankton.http.type_response = await lib_plankton.rest_http.call(
 								rest_subject,
 								http_request,
 								{
@@ -428,9 +523,10 @@ async function main(
 		}
 	}
 	
+}
 
 (
-	main(process.argv.slice(2))
+	_espe.main(process.argv.slice(2))
 	.then(
 		() => {
 		}

source/repositories/invite.ts

@@ -0,0 +1,332 @@
+/*
+Espe | Ein schlichtes Werkzeug zur Mitglieder-Verwaltung | Backend
+Copyright (C) 2024 Christian Fraß
+
+This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public 
+License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later 
+version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied 
+warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with this program. If not, see 
+<https://www.gnu.org/licenses/>. 
+ */
+
+namespace _espe.repository.invite
+{
+
+	/**
+	 */
+	type type_group_chest = lib_plankton.storage.type_chest<
+		Array<any>,
+		Record<string, any>,
+		lib_plankton.database.type_description_create_table,
+		lib_plankton.storage.sql_table_common.type_sql_table_common_search_term,
+		Record<string, any>
+	>;
+	
+	
+	/**
+	 */
+	var _core_store : (
+		null
+		|
+		lib_plankton.storage.type_store<
+			_espe.type.invite_id,
+			Record<string, any>,
+			{},
+			lib_plankton.storage.type_sql_table_autokey_search_term,
+			Record<string, any>
+		>
+	) = null;
+	
+	
+	/**
+	 */
+	var _group_chest : (
+		null
+		|
+		type_group_chest
+	) = null;
+	
+	
+	/**
+	 */
+	function get_core_store(
+	) : lib_plankton.storage.type_store<
+		_espe.type.invite_id,
+		Record<string, any>,
+		{},
+		lib_plankton.storage.type_sql_table_autokey_search_term,
+		Record<string, any>
+	>
+	{
+		if (_core_store === null) {
+			_core_store = lib_plankton.storage.sql_table_autokey_store(
+				{
+					"database_implementation": _espe.helpers.database_implementation(),
+					"table_name": "invites",
+					"key_name": "id",
+				}
+			);
+		}
+		else {
+			// do nothing
+		}	
+		return _core_store;
+	}
+	
+	
+	/**
+	 */
+	function get_group_chest(
+	) : type_group_chest
+	{
+		if (_group_chest === null) {
+			_group_chest = lib_plankton.storage.sql_table_common.chest(
+				{
+					"database_implementation": _espe.helpers.database_implementation(),
+					"table_name": "invite_groups",
+					"key_names": ["invite_id","group_name"],
+				}
+			);
+		}
+		else {
+			// do nothing
+		}
+		return _group_chest;
+	}
+	
+	
+	/**
+	 */
+	type type_dispersal = {
+		core_row : Record<string, any>;
+		group_rows : Array<
+			Record<string, any>
+		>;
+	};
+	
+	
+	/**
+	 */
+	function encode(
+		object : _espe.type.invite_object
+	) : type_dispersal
+	{
+		return {
+			"core_row": {
+				"key": object.key,
+				"expiry": object.expiry,
+				"membership_number_mode": _espe.helpers.invite_prefill_mode_encode(object.membership_number_mode),
+				"membership_number_value": object.membership_number_value,
+				"name_mode": _espe.helpers.invite_prefill_mode_encode(object.name_mode),
+				"name_value": object.name_value,
+				"email_address_mode": _espe.helpers.invite_prefill_mode_encode(object.email_address_mode),
+				"email_address_value": object.email_address_value,
+				"groups_mode": _espe.helpers.invite_prefill_mode_encode(object.groups_mode),
+			},
+			"group_rows": (
+				object.groups_value
+				.map(
+					group => ({
+						"group_name": group,
+					})
+				)
+			)
+		};
+	}
+	
+	
+	/**
+	 */
+	function decode(
+		dispersal : type_dispersal
+	) : _espe.type.invite_object
+	{
+		return {
+			"key": dispersal.core_row["key"],
+			"expiry": dispersal.core_row["expiry"],
+			"membership_number_mode": _espe.helpers.invite_prefill_mode_decode(dispersal.core_row["membership_number_mode"]),
+			"membership_number_value": dispersal.core_row["membership_number_value"],
+			"name_mode": _espe.helpers.invite_prefill_mode_decode(dispersal.core_row["name_mode"]),
+			"name_value": dispersal.core_row["name_value"],
+			"email_address_mode": _espe.helpers.invite_prefill_mode_decode(dispersal.core_row["email_address_mode"]),
+			"email_address_value": dispersal.core_row["email_address_value"],
+			"groups_mode": _espe.helpers.invite_prefill_mode_decode(dispersal.core_row["groups_mode"]),
+			"groups_value": lib_plankton.list.sorted<string>(
+				dispersal.group_rows.map(row => row["group_name"]),
+				{
+					"compare_element": (group1, group2) => (group1 <= group2)
+				}
+			),
+		};
+	}
+	
+	
+	/**
+	 * @todo optimize
+	 */
+	export async function list(
+		search_term : (null | string)
+	) : Promise<
+		Array<
+			{
+				id : _espe.type.invite_id;
+				preview : {
+					name : string;
+				};
+			}
+		>
+	>
+	{
+		return (
+			(await get_core_store().search(null))
+			.filter(
+				({"key": key, "preview": preview}) => (
+					(search_term === null)
+					?
+					true
+					:
+					(preview["key"] === search_term)
+				)
+			)
+			.map(
+				({"key": key, "preview": preview}) => ({
+					"id": key,
+					"preview": {
+						"name": preview["name_value"],
+					}
+				})
+			)
+		);
+	}
+	
+	
+	/**
+	 */
+	export async function read(
+		id : _espe.type.invite_id
+	) : Promise<_espe.type.invite_object>
+	{
+		const core_row : Record<string, any> = await get_core_store().read(id);
+		const group_hits : Array<{key : Record<string, any>; preview : Record<string, any>;}> = await get_group_chest().search(
+			{
+				"expression": "invite_id = $invite_id",
+				"arguments": {"invite_id": id}
+			}
+		);
+		
+		const dispersal : type_dispersal = {
+			"core_row": core_row,
+			"group_rows": group_hits.map(
+				hit => ({
+					"group_name": hit.preview["group_name"]
+				})
+			),
+		};
+		
+		return decode(dispersal);
+	}
+	
+	
+	/**
+	 */
+	export async function create(
+		value : _espe.type.invite_object
+	) : Promise<_espe.type.invite_id>
+	{
+		const dispersal : type_dispersal = encode(value);
+		
+		// core
+		const id : _espe.type.invite_id = await get_core_store().create(dispersal.core_row);
+		
+		// groups
+		for await (const group_row of dispersal.group_rows) {
+			await get_group_chest().write(
+				[
+					id,
+					group_row["group_name"],
+				],
+				{
+					"_dummy": null,
+				}
+			);
+		}
+		
+		return id;
+	}
+	
+	
+	/**
+	 */
+	export async function delete_(
+		id : _espe.type.invite_id
+	) : Promise<void>
+	{
+		// groups
+		const hits : Array<{key : Array<any>; preview : Record<string, any>;}> = await get_group_chest().search(
+			{
+				"expression": "invite_id = $invite_id",
+				"arguments": {"invite_id": id}
+			}
+		);
+		for (const hit of hits) {
+			await get_group_chest().delete(hit.key);
+		}
+		
+		// core
+		await get_core_store().delete(id);
+	}
+	
+	
+	/**
+	 */
+	export async function identify(
+		key : _espe.type.invite_key
+	) : Promise<_espe.type.invite_id>
+	{
+		const hits : Array<{id : _espe.type.invite_id; preview : any;}> = await list(key);
+		return (
+			(hits.length !== 1)
+			?
+			Promise.reject<_espe.type.invite_id>(new Error("not found"))
+			:
+			Promise.resolve<_espe.type.invite_id>(hits[0].id)
+		);
+	}
+	
+	
+	/**
+	 */
+	export async function dump(
+	) : Promise<
+		Array<
+			{
+				id : _espe.type.invite_id;
+				object : _espe.type.invite_object;
+			}
+		>
+	>
+	{
+		return (
+			Promise.all(
+				(await get_core_store().search(null))
+				.map(hit => hit.key)
+				.map(
+					id => (
+						read(id)
+						.then(
+							(object) => ({
+								"id": id,
+								"object": object
+							})
+						)
+					)
+				)
+			)
+		);
+	}
+	
+}

source/repositories/member.ts

@@ -156,7 +156,9 @@ namespace _espe.repository.member
 			"email_address_private": dispersal.core_row["email_address_private"],
 			"groups": lib_plankton.list.sorted<string>(
 				dispersal.group_rows.map(row => row["group_name"]),
-				(group1, group2) => ((group1 <= group2) ? 0 : 1)
+				{
+					"compare_element": (group1, group2) => (group1 <= group2)
+				}
 			),
 			"registered": (dispersal.core_row["registered"] > 0),
 			"enabled": (dispersal.core_row["enabled"] > 0),

source/services/invite.ts

@@ -0,0 +1,192 @@
+/*
+Espe | Ein schlichtes Werkzeug zur Mitglieder-Verwaltung | Backend
+Copyright (C) 2024 Christian Fraß
+
+This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public 
+License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later 
+version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied 
+warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with this program. If not, see 
+<https://www.gnu.org/licenses/>. 
+ */
+
+namespace _espe.service.invite
+{
+	
+	/**
+	 */
+	export async function create(
+		{
+			"membership_number_mode": membership_number_mode,
+			"membership_number_value": membership_number_value,
+			"name_mode": name_mode,
+			"name_value": name_value,
+			"email_address_mode": email_address_mode,
+			"email_address_value": email_address_value,
+			"groups_mode": groups_mode,
+			"groups_value": groups_value,
+		} : {
+			membership_number_mode : _espe.type.invite_prefill_mode;
+			membership_number_value : (null | string);
+			name_mode : _espe.type.invite_prefill_mode;
+			name_value : string;
+			email_address_mode : _espe.type.invite_prefill_mode;
+			email_address_value : (null | string);
+			groups_mode : _espe.type.invite_prefill_mode;
+			groups_value : Array<string>;
+		},
+		{
+			"expiry": expiry = -1,
+		} : {
+			expiry ?: (null | int);
+		} = {
+		}
+	) : Promise<{id : _espe.type.invite_id; key : _espe.type.invite_key}>
+	{
+		/**
+		 * @todo outsource to conf
+		 */
+		const default_lifetime : int = (60 * 60 * 24 * 7 * 2);
+		/**
+		 * @todo proper salt
+		 */
+		const invite_key : _espe.type.invite_key = lib_plankton.sha256.get(
+			(
+				name_value
+				+
+				"/"
+				+
+				lib_plankton.base.get_current_timestamp(true).toFixed(0)
+			),
+			"secret"
+		);
+		const invite_object : _espe.type.invite_object = {
+			"key": invite_key,
+			"expiry": (
+				((expiry !== null) && (expiry < 0))
+				?
+				(lib_plankton.base.get_current_timestamp(true) + default_lifetime)
+				:
+				expiry
+			),
+			"membership_number_mode": membership_number_mode,
+			"membership_number_value": membership_number_value,
+			"name_mode": name_mode,
+			"name_value": name_value,
+			"email_address_mode": email_address_mode,
+			"email_address_value": email_address_value,
+			"groups_mode": groups_mode,
+			"groups_value": groups_value,
+		};
+		const invite_id : _espe.type.invite_id = await _espe.repository.invite.create(invite_object);
+		return {
+			"id": invite_id,
+			"key": invite_key,
+		};
+	}
+	
+	
+	/**
+	 */
+	function get(
+		key : _espe.type.invite_key
+	) : Promise<_espe.type.invite_object>
+	{
+		return (
+			_espe.repository.invite.identify(key)
+			.then(
+				(id) => _espe.repository.invite.read(id)
+			)
+		);
+	}
+	
+	
+	/**
+	 */
+	export async function examine(
+		key : _espe.type.invite_key
+	) : Promise<_espe.type.invite_object>
+	{
+		let invite_object : (null | _espe.type.invite_object);
+		try {
+			invite_object = await get(key)
+		}
+		catch (error) {
+			invite_object = null;
+		}
+		if (invite_object === null) {
+			return Promise.reject(new Error("not found"))
+		}
+		else {
+			const now : int = lib_plankton.base.get_current_timestamp(true);
+			if ((invite_object.expiry !== null) && (invite_object.expiry >= now)) {
+				return Promise.reject(new Error("expired"));
+			}
+			else {
+				return Promise.resolve(invite_object);
+			}
+		}
+	}
+	
+	
+	/**
+	 * @todo heed expiry
+	 * @todo password?
+	 */
+	export async function accept(
+		key : _espe.type.invite_key,
+		membership_number_value : (null | string),
+		name_value : (null | string),
+		email_address_value : (null | string),
+		groups_value : Array<string>
+	) : Promise<void>
+	{
+		const invite_id : _espe.type.invite_id = await _espe.repository.invite.identify(key);
+		const invite_object : _espe.type.invite_object = await _espe.repository.invite.read(invite_id);
+		const member_id : _espe.type.member_id = await _espe.service.member.project(
+			{
+				"membership_number": (
+					(invite_object.membership_number_mode === _espe.type.invite_prefill_mode.free)
+					?
+					membership_number_value
+					:
+					invite_object.membership_number_value
+				),
+				"name_real_value": (
+					(
+						(invite_object.name_mode === _espe.type.invite_prefill_mode.free)
+						&&
+						(name_value !== null)
+					)
+					?
+					name_value
+					:
+					invite_object.name_value
+				),
+				"email_address_private": (
+					(
+						(invite_object.email_address_mode === _espe.type.invite_prefill_mode.free)
+						&&
+						(email_address_value !== null)
+					)
+					?
+					email_address_value
+					:
+					invite_object.email_address_value
+				),
+				"groups": (
+					(invite_object.groups_mode === _espe.type.invite_prefill_mode.free)
+					?
+					groups_value
+					:
+					invite_object.groups_value
+				),
+			}
+		);
+		await _espe.repository.invite.delete_(invite_id);
+	}
+	
+}

source/types.ts

@@ -55,4 +55,39 @@ namespace _espe.type
 		password_change_token : (null | string);
 	};
 	
+	
+	/**
+	 */
+	export type invite_id = int;
+	
+	
+	/**
+	 */
+	export type invite_key = string;
+	
+	
+	/**
+	 */
+	export enum invite_prefill_mode {
+		hidden,
+		locked,
+		free,
+	};
+	
+	
+	/**
+	 */
+	export type invite_object = {
+		key : invite_key;
+		expiry : (null | int);
+		membership_number_mode : invite_prefill_mode;
+		membership_number_value : (null | string);
+		name_mode : invite_prefill_mode;
+		name_value : string;
+		email_address_mode : invite_prefill_mode;
+		email_address_value : (null | string);
+		groups_mode : invite_prefill_mode;
+		groups_value : Array<string>;
+	};
+	
 }

tools/makefile

@@ -51,9 +51,11 @@ ${dir_temp}/espe-core.js ${dir_temp}/espe-core.d.ts: \
 		${dir_source}/repositories/admin.ts \
 		${dir_source}/repositories/name_index.ts \
 		${dir_source}/repositories/member.ts \
+		${dir_source}/repositories/invite.ts \
+		${dir_source}/services/admin.ts \
 		${dir_source}/services/name_index.ts \
 		${dir_source}/services/member.ts \
-		${dir_source}/services/admin.ts \
+		${dir_source}/services/invite.ts \
 		${dir_source}/api/base.ts \
 		${dir_source}/api/actions/meta_ping.ts \
 		${dir_source}/api/actions/meta_spec.ts \
@@ -69,6 +71,9 @@ ${dir_temp}/espe-core.js ${dir_temp}/espe-core.d.ts: \
 		${dir_source}/api/actions/member_delete.ts \
 		${dir_source}/api/actions/member_password_change_initialize.ts \
 		${dir_source}/api/actions/member_password_change_execute.ts \
+		${dir_source}/api/actions/invite_create.ts \
+		${dir_source}/api/actions/invite_examine.ts \
+		${dir_source}/api/actions/invite_accept.ts \
 		${dir_source}/api/functions.ts \
 		${dir_source}/conf.ts
 	@ ${cmd_log} "compile | core …"

tools/update-plankton

@@ -16,8 +16,8 @@ modules="${modules} storage"
 modules="${modules} session"
 modules="${modules} json"
 modules="${modules} api"
-modules="${modules} rest"
 modules="${modules} http"
+modules="${modules} rest_http"
 modules="${modules} server"
 modules="${modules} email"
 modules="${modules} args"