@stevenkellner/team-conduct-api 1.0.35 → 2.0.1

package/src/functions/team/new.ts

@@ -1,22 +1,18 @@
-import { Flattable, ObjectTypeBuilder, UtcDate, ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
-import { FirebaseFunction, FunctionsError } from '@stevenkellner/firebase-function';
-import { Person, PersonPrivateProperties, PersonSignInProperties, User, UserRole, Team, NotificationProperties } from '../../types';
-import { Firestore } from '../../Firestore';
+import { Flattable, ObjectTypeBuilder, ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
+import { FirebaseFunction } from '@stevenkellner/firebase-function';
+import { Person, PersonPrivateProperties, User, Team } from '../../types';
 
-export namespace TeamNewFunction {
+export type TeamNewFunctionParameters = {
+    id: Team.Id
+    name: string
+    paypalMeLink: string | null
+    personId: Person.Id
+    personProperties: PersonPrivateProperties
+};
 
-    export type Parameters = {
-        id: Team.Id
-        name: string
-        paypalMeLink: string | null
-        personId: Person.Id
-        personProperties: PersonPrivateProperties
-    }
-}
-
-export class TeamNewFunction extends FirebaseFunction<TeamNewFunction.Parameters, User> {
+export abstract class TeamNewFunctionBase extends FirebaseFunction<TeamNewFunctionParameters, User> {
 
-    public parametersBuilder = new ObjectTypeBuilder<Flattable.Flatten<TeamNewFunction.Parameters>, TeamNewFunction.Parameters>({
+    public parametersBuilder = new ObjectTypeBuilder<Flattable.Flatten<TeamNewFunctionParameters>, TeamNewFunctionParameters>({
         id: Team.Id.builder,
         name: new ValueTypeBuilder(),
         paypalMeLink: new ValueTypeBuilder(),
@@ -25,30 +21,4 @@ export class TeamNewFunction extends FirebaseFunction<TeamNewFunction.Parameters
     });
 
     public returnTypeBuilder = User.builder;
-
-    public async execute(parameters: TeamNewFunction.Parameters): Promise<User> {
-
-        if (this.userId === null)
-            throw new FunctionsError('permission-denied', 'User is not authenticated');
-        const userId = User.Id.builder.build(this.userId);
-
-        const teamSnapshot = await Firestore.shared.team(parameters.id).snapshot();
-        if (teamSnapshot.exists)
-            throw new FunctionsError('already-exists', 'Team already exists');
-
-        const userSnapshot = await Firestore.shared.user(userId).snapshot();
-        let user = new User(userId);
-        if (userSnapshot.exists)
-            user = User.builder.build(userSnapshot.data);
-
-        user.teams.set(parameters.id, new User.TeamProperties(parameters.name, parameters.personId));
-        await Firestore.shared.user(userId).set(user);
-
-        await Firestore.shared.team(parameters.id).set(new Team(parameters.id, parameters.name, parameters.paypalMeLink));
-
-        const signInProperties = new PersonSignInProperties(userId, UtcDate.now, new NotificationProperties(), UserRole.all);
-        await Firestore.shared.person(parameters.id, parameters.personId).set(new Person(parameters.personId, parameters.personProperties, [], signInProperties));
-
-        return user;
-    }
 }

package/src/functions/user/kickout.ts

@@ -1,51 +1,18 @@
-import { FirebaseFunction, FunctionsError } from '@stevenkellner/firebase-function';
-import { Person, Team, User } from '../../types';
+import { FirebaseFunction } from '@stevenkellner/firebase-function';
+import { Team, User } from '../../types';
 import { Flattable, ObjectTypeBuilder, ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
-import { Firestore } from '../../Firestore';
-import { checkAuthentication } from '../../checkAuthentication';
 
-export namespace UserKickoutFunction {
+export type UserKickoutFunctionParameters = {
+    teamId: Team.Id
+    userId: User.Id
+};
 
-    export type Parameters = {
-        teamId: Team.Id
-        userId: User.Id
-    };
-}
-
-export class UserKickoutFunction extends FirebaseFunction<UserKickoutFunction.Parameters, void> {
+export abstract class UserKickoutFunctionBase extends FirebaseFunction<UserKickoutFunctionParameters, void> {
 
-    public parametersBuilder = new ObjectTypeBuilder<Flattable.Flatten<UserKickoutFunction.Parameters>, UserKickoutFunction.Parameters>({
+    public parametersBuilder = new ObjectTypeBuilder<Flattable.Flatten<UserKickoutFunctionParameters>, UserKickoutFunctionParameters>({
         teamId: Team.Id.builder,
         userId: User.Id.builder
     });
 
     public returnTypeBuilder = new ValueTypeBuilder<void>();
-
-    public async execute(parameters: UserKickoutFunction.Parameters): Promise<void> {
-
-        const userId = await checkAuthentication(this.userId, parameters.teamId, 'team-manager');
-
-        if (userId.value === parameters.userId.value)
-            throw new FunctionsError('invalid-argument', 'You cannot kick yourself out of a team.');
-
-        const userSnapshot = await Firestore.shared.user(parameters.userId).snapshot();
-        if (!userSnapshot.exists)
-            throw new FunctionsError('not-found', 'User not found.');
-        const user = User.builder.build(userSnapshot.data);
-
-        const userTeamProperties = user.teams.getOptional(parameters.teamId);
-        if (userTeamProperties === null)
-            throw new FunctionsError('not-found', 'User is not a member of the team.');
-
-        const personSnapshot = await Firestore.shared.person(parameters.teamId, userTeamProperties.personId).snapshot();
-        if (!personSnapshot.exists)
-            throw new FunctionsError('not-found', 'Person not found.');
-        const person = Person.builder.build(personSnapshot.data);
-
-        person.signInProperties = null;
-        await Firestore.shared.person(parameters.teamId, userTeamProperties.personId).set(person);
-
-        user.teams.delete(parameters.teamId);
-        await Firestore.shared.user(parameters.userId).set(user);
-    }
 }

package/src/functions/user/login.ts

@@ -1,24 +1,10 @@
-import { FirebaseFunction, FunctionsError } from '@stevenkellner/firebase-function';
+import { FirebaseFunction } from '@stevenkellner/firebase-function';
 import { User } from '../../types';
 import { ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
-import { Firestore } from '../../Firestore';
 
-export class UserLoginFunction extends FirebaseFunction<null, User> {
+export abstract class UserLoginFunctionBase extends FirebaseFunction<null, User> {
 
     public parametersBuilder = new ValueTypeBuilder<null>();
 
     public returnTypeBuilder = User.builder;
-
-    public async execute(): Promise<User> {
-
-        if (this.userId === null)
-            throw new FunctionsError('unauthenticated', 'User is not authenticated.');
-        const userId = User.Id.builder.build(this.userId);
-
-        const userSnapshot = await Firestore.shared.user(userId).snapshot();
-        if (!userSnapshot.exists)
-            throw new FunctionsError('not-found', 'User not found.');
-
-        return User.builder.build(userSnapshot.data);
-    }
 }

package/src/functions/user/roleEdit.ts

@@ -1,44 +1,20 @@
-import { FirebaseFunction, FunctionsError } from '@stevenkellner/firebase-function';
-import { checkAuthentication } from '../../checkAuthentication';
+import { FirebaseFunction } from '@stevenkellner/firebase-function';
 import { Person, Team, UserRole } from '../../types';
 import { ArrayTypeBuilder, Flattable, ObjectTypeBuilder, ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
-import { Firestore } from '../../Firestore';
 
-export namespace UserRoleEditFunction {
+export type UserRoleEditFunctionParameters = {
+    teamId: Team.Id
+    personId: Person.Id
+    roles: UserRole[]
+};
 
-    export type Parameters = {
-        teamId: Team.Id
-        personId: Person.Id
-        roles: UserRole[]
-    };
-}
-
-export class UserRoleEditFunction extends FirebaseFunction<UserRoleEditFunction.Parameters, void> {
+export abstract class UserRoleEditFunctionBase extends FirebaseFunction<UserRoleEditFunctionParameters, void> {
 
-    public parametersBuilder = new ObjectTypeBuilder<Flattable.Flatten<UserRoleEditFunction.Parameters>, UserRoleEditFunction.Parameters>({
+    public parametersBuilder = new ObjectTypeBuilder<Flattable.Flatten<UserRoleEditFunctionParameters>, UserRoleEditFunctionParameters>({
         teamId: Team.Id.builder,
         personId: Person.Id.builder,
         roles: new ArrayTypeBuilder(new ValueTypeBuilder())
     });
 
     public returnTypeBuilder = new ValueTypeBuilder<void>();
-
-    public async execute(parameters: UserRoleEditFunction.Parameters): Promise<void> {
-
-        const userId = await checkAuthentication(this.userId, parameters.teamId, 'team-manager');
-
-        const personSnapshot = await Firestore.shared.person(parameters.teamId, parameters.personId).snapshot();
-        if (!personSnapshot.exists)
-            throw new FunctionsError('not-found', 'User does not exist');
-        const person = Person.builder.build(personSnapshot.data);
-
-        if (person.signInProperties === null)
-            throw new FunctionsError('permission-denied', 'User is not signed in');
-
-        if (person.signInProperties.userId.value === userId.value && !parameters.roles.includes('team-manager'))
-            throw new FunctionsError('unavailable', 'User cannot remove their own team-manager role');
-
-        person.signInProperties.roles = parameters.roles;
-        await Firestore.shared.person(parameters.teamId, parameters.personId).set(person);
-    }
 }

package/src/index.ts

@@ -1,8 +1,3 @@
 export * from './firebase';
 export * from './functions';
 export * from './types';
-export * from './checkAuthentication';
-export * from './firebaseFunctionsContext';
-export * from './Firestore';
-export * from './FirestoreScheme';
-export * from './pushNotification';

package/src/locales/de.ts

@@ -1,6 +1,15 @@
 import { Pluralization } from '../types/Pluralization';
+import { LocalizationDict } from '../types/Localization';
 
-export const localizationDE = {
+/**
+ * German (de) localization strings for the application.
+ * Contains translations for notifications, fine amounts, fine template repetitions,
+ * payment states, and user roles.
+ *
+ * Supports template variables using {{variableName}} syntax that will be replaced
+ * at runtime with actual values.
+ */
+export const localizationDE: LocalizationDict = {
     notification: {
         fine: {
             new: {

package/src/locales/en.ts

@@ -1,6 +1,25 @@
 import { Pluralization } from '../types/Pluralization';
+import { SubLocalizationType } from '../types/Localization';
 
-export const localizationEN = {
+/**
+ * Helper function to ensure a value satisfies the Localization structure
+ * while preserving its concrete type (as const) for type inference.
+ * @param value - The localization object to validate
+ * @returns The same value with its inferred type preserved
+ */
+const satisfiesLocalization = <T extends { [Key in string]: SubLocalizationType }>(value: T): T => value;
+
+/**
+ * English (en) localization strings for the application.
+ * Contains translations for notifications, fine amounts, fine template repetitions,
+ * payment states, and user roles.
+ *
+ * Supports template variables using {{variableName}} syntax that will be replaced
+ * at runtime with actual values.
+ *
+ * This serves as the base localization - other locales should match this structure.
+ */
+export const localizationEN = satisfiesLocalization({
     notification: {
         fine: {
             new: {
@@ -95,4 +114,4 @@ export const localizationEN = {
         fineCanAdd: 'Can add fines',
         teamManager: 'Team Manager'
     }
-}
+});

package/src/types/Configuration.ts

@@ -1,13 +1,27 @@
-import { localizations } from './Localization';
-import { Flattable, ITypeBuilder, keys, ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
-
+import { Flattable, ITypeBuilder } from '@stevenkellner/typescript-common-functionality';
+import { Currency } from './Currency';
+import { Locale } from './Locale';
+
+/**
+ * Represents the configuration settings that will be passed to the functions parameters.
+ * Contains currency and locale preferences.
+ */
 export class Configuration implements Flattable<Configuration.Flatten> {
 
+    /**
+     * Creates a new Configuration instance.
+     * @param currency - The currency to use for monetary values (EUR, USD, ...)
+     * @param locale - The locale for localization (language/region)
+     */
     public constructor(
-        public currency: Configuration.Currency,
-        public locale: Configuration.Locale
+        public currency: Currency,
+        public locale: Locale
     ) {}
 
+    /**
+     * Returns the flattened representation of the configuration.
+     * @returns The flattened configuration object
+     */
     public get flatten(): Configuration.Flatten {
         return {
             currency: this.currency,
@@ -18,31 +32,24 @@ export class Configuration implements Flattable<Configuration.Flatten> {
 
 export namespace Configuration {
 
-    export type Currency = 'EUR' | 'USD';
-
-    export namespace Currency {
-
-        export const all: Currency[] = ['EUR', 'USD'];
-
-        export const builder = new ValueTypeBuilder<Currency>();
-    }
-
-    export type Locale = keyof typeof localizations;
-
-    export namespace Locale {
-
-        export const all: Locale[] = keys(localizations);
-
-        export const builder = new ValueTypeBuilder<Locale>();
-    }
-
+    /**
+     * Flattened representation of Configuration for serialization.
+     */
     export type Flatten = {
         currency: Currency,
         locale: Locale
     };
 
+    /**
+     * TypeBuilder for constructing Configuration instances from flattened data.
+     */
     export class TypeBuilder implements ITypeBuilder<Flatten, Configuration> {
 
+        /**
+         * Builds a Configuration instance from flattened data.
+         * @param flatten - The flattened configuration data
+         * @returns A new Configuration instance
+         */
         public build(flatten: Flatten): Configuration {
             return new Configuration(
                 flatten.currency,
@@ -51,5 +58,8 @@ export namespace Configuration {
         }
     }
 
+    /**
+     * Singleton builder instance for Configuration.
+     */
     export const builder = new TypeBuilder();
 }

package/src/types/Currency.ts

@@ -0,0 +1,24 @@
+import { ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
+
+/**
+ * Array of all available currencies.
+ */
+const currencies = ['EUR', 'USD'] as const;
+
+/**
+ * Supported currency types.
+ */
+export type Currency = typeof currencies[number];
+
+export namespace Currency {
+
+    /**
+     * Array of all available currencies.
+     */
+    export const all: readonly Currency[] = currencies;
+
+    /**
+     * Builder for constructing Currency values.
+     */
+    export const builder = new ValueTypeBuilder<Currency>();
+}

package/src/types/Fine.ts

@@ -2,8 +2,22 @@ import { Flattable, Guid, ITypeBuilder, Tagged, UtcDate } from '@stevenkellner/t
 import { FineAmount } from './FineAmount';
 import { PayedState } from './PayedState';
 
+/**
+ * Represents a fine assigned to a person in a team.
+ *
+ * Contains information about the fine's payment status, date, reason, and monetary amount.
+ */
 export class Fine implements Flattable<Fine.Flatten> {
 
+    /**
+     * Creates a new Fine instance.
+     *
+     * @param id - Unique identifier for the fine (GUID)
+     * @param payedState - Payment status ('payed' or 'notPayed')
+     * @param date - Date when the fine was issued
+     * @param reason - Description or reason for the fine
+     * @param amount - Monetary amount of the fine
+     */
     public constructor(
         public id: Fine.Id,
         public payedState: PayedState,
@@ -12,6 +26,9 @@ export class Fine implements Flattable<Fine.Flatten> {
         public amount: FineAmount
     ) {}
 
+    /**
+     * Returns the flattened representation for serialization.
+     */
     public get flatten(): Fine.Flatten {
         return {
             id: this.id.flatten,
@@ -25,15 +42,27 @@ export class Fine implements Flattable<Fine.Flatten> {
 
 export namespace Fine {
 
+    /**
+     * Tagged GUID type for fine identifiers.
+     */
     export type Id = Tagged<Guid, 'fine'>;
 
     export namespace Id {
 
+        /**
+         * Flattened representation of a fine ID (GUID string).
+         */
         export type Flatten = string;
 
+        /**
+         * Type builder for Fine.Id serialization/deserialization.
+         */
         export const builder = Tagged.builder('fine' as const, Guid.builder);
     }
 
+    /**
+     * Flattened representation of a Fine for serialization.
+     */
     export type Flatten = {
         id: Id.Flatten,
         payedState: PayedState,
@@ -42,8 +71,17 @@ export namespace Fine {
         amount: FineAmount.Flatten
     };
 
+    /**
+     * Type builder for Fine serialization/deserialization.
+     */
     export class TypeBuilder implements ITypeBuilder<Flatten, Fine> {
 
+        /**
+         * Builds a Fine instance from flattened data.
+         *
+         * @param value - Flattened fine data
+         * @returns Fine instance
+         */
         public build(value: Flatten): Fine {
             return new Fine(
                 Id.builder.build(value.id),
@@ -55,5 +93,8 @@ export namespace Fine {
         }
     }
 
+    /**
+     * Singleton instance of TypeBuilder for Fine.
+     */
     export const builder = new TypeBuilder();
 }