@stevenkellner/team-conduct-api 1.0.35 → 2.0.1

package/lib/src/types/Team.d.ts

@@ -1,24 +1,62 @@
 import { Flattable, Guid, ITypeBuilder, Tagged } from '@stevenkellner/typescript-common-functionality';
+/**
+ * Represents a team in the system with its basic information.
+ *
+ * A team is a group of people who can track fines and payments together.
+ * Teams can optionally have a PayPal.Me link for simplified payment collection.
+ */
 export declare class Team implements Flattable<Team.Flatten> {
     id: Team.Id;
     name: string;
     paypalMeLink: string | null;
+    /**
+     * Creates a new Team instance.
+     * @param id - The unique identifier for this team
+     * @param name - The display name of the team
+     * @param paypalMeLink - Optional PayPal.Me link for payment collection (null if not set)
+     */
     constructor(id: Team.Id, name: string, paypalMeLink: string | null);
+    /**
+     * Gets the flattened representation of this team for serialization.
+     */
     get flatten(): Team.Flatten;
 }
 export declare namespace Team {
+    /**
+     * Tagged type for team identifiers to prevent mixing with other GUID types.
+     */
     type Id = Tagged<Guid, 'team'>;
     namespace Id {
+        /**
+         * Flattened representation of a team ID (plain GUID string).
+         */
         type Flatten = string;
+        /**
+         * Builder for constructing Team.Id instances from GUID strings.
+         */
         const builder: Tagged.TypeBuilder<Guid, "team">;
     }
+    /**
+     * Flattened representation of a Team for serialization.
+     */
     type Flatten = {
         id: Id.Flatten;
         name: string;
         paypalMeLink: string | null;
     };
+    /**
+     * Builder for constructing Team instances from flattened data.
+     */
     class TypeBuilder implements ITypeBuilder<Flatten, Team> {
+        /**
+         * Builds a Team instance from flattened data.
+         * @param value - The flattened team data
+         * @returns A new Team instance
+         */
         build(value: Flatten): Team;
     }
+    /**
+     * Singleton builder instance for Team.
+     */
     const builder: TypeBuilder;
 }

package/lib/src/types/Team.js

@@ -2,15 +2,30 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Team = void 0;
 const typescript_common_functionality_1 = require("@stevenkellner/typescript-common-functionality");
+/**
+ * Represents a team in the system with its basic information.
+ *
+ * A team is a group of people who can track fines and payments together.
+ * Teams can optionally have a PayPal.Me link for simplified payment collection.
+ */
 class Team {
     id;
     name;
     paypalMeLink;
+    /**
+     * Creates a new Team instance.
+     * @param id - The unique identifier for this team
+     * @param name - The display name of the team
+     * @param paypalMeLink - Optional PayPal.Me link for payment collection (null if not set)
+     */
     constructor(id, name, paypalMeLink) {
         this.id = id;
         this.name = name;
         this.paypalMeLink = paypalMeLink;
     }
+    /**
+     * Gets the flattened representation of this team for serialization.
+     */
     get flatten() {
         return {
             id: this.id.flatten,
@@ -23,13 +38,27 @@ exports.Team = Team;
 (function (Team) {
     let Id;
     (function (Id) {
+        /**
+         * Builder for constructing Team.Id instances from GUID strings.
+         */
         Id.builder = typescript_common_functionality_1.Tagged.builder('team', typescript_common_functionality_1.Guid.builder);
     })(Id = Team.Id || (Team.Id = {}));
+    /**
+     * Builder for constructing Team instances from flattened data.
+     */
     class TypeBuilder {
+        /**
+         * Builds a Team instance from flattened data.
+         * @param value - The flattened team data
+         * @returns A new Team instance
+         */
         build(value) {
             return new Team(Id.builder.build(value.id), value.name, value.paypalMeLink);
         }
     }
     Team.TypeBuilder = TypeBuilder;
+    /**
+     * Singleton builder instance for Team.
+     */
     Team.builder = new TypeBuilder();
 })(Team || (exports.Team = Team = {}));

package/lib/src/types/User.d.ts

@@ -1,40 +1,105 @@
 import { Dictionary, Flattable, ITypeBuilder, Tagged } from '@stevenkellner/typescript-common-functionality';
 import { Team } from './Team';
 import { Person } from './Person';
+/**
+ * Represents a user in the system with associated team memberships.
+ *
+ * A user can be a member of multiple teams, and for each team, they have
+ * specific properties (team name and associated person ID).
+ */
 export declare class User implements Flattable<User.Flatten> {
     id: User.Id;
     teams: Dictionary<Team.Id, User.TeamProperties>;
+    /**
+     * Creates a new User instance.
+     * @param id - The unique identifier for this user
+     * @param teams - Dictionary mapping team IDs to team-specific user properties
+     */
     constructor(id: User.Id, teams?: Dictionary<Team.Id, User.TeamProperties>);
+    /**
+     * Gets the flattened representation of this user for serialization.
+     */
     get flatten(): User.Flatten;
 }
 export declare namespace User {
+    /**
+     * Tagged type for user identifiers to prevent mixing with other string IDs.
+     */
     type Id = Tagged<string, 'user'>;
     namespace Id {
+        /**
+         * Flattened representation of a user ID (plain string).
+         */
         type Flatten = string;
+        /**
+         * Builder for constructing User.Id instances from strings.
+         */
         const builder: Tagged.TypeBuilder<string, "user">;
     }
+    /**
+     * Properties that are specific to a user's membership in a particular team.
+     */
     class TeamProperties implements Flattable<TeamProperties.Flatten> {
-        name: string;
+        teamId: Team.Id;
+        teamName: string;
         personId: Person.Id;
-        constructor(name: string, personId: Person.Id);
+        /**
+         * Creates new team-specific user properties.
+         * @param teamId - The ID of the team
+         * @param teamName - The display name of the team
+         * @param personId - The ID of the person associated with this user in this team
+         */
+        constructor(teamId: Team.Id, teamName: string, personId: Person.Id);
+        /**
+         * Gets the flattened representation of these team properties.
+         */
         get flatten(): TeamProperties.Flatten;
     }
     namespace TeamProperties {
+        /**
+         * Flattened representation of team properties for serialization.
+         */
         type Flatten = {
-            name: string;
+            teamId: Team.Id.Flatten;
+            teamName: string;
             personId: Person.Id.Flatten;
         };
+        /**
+         * Builder for constructing TeamProperties from flattened data.
+         */
         class TypeBuilder implements ITypeBuilder<Flatten, TeamProperties> {
+            /**
+             * Builds a TeamProperties instance from flattened data.
+             * @param value - The flattened team properties data
+             * @returns A new TeamProperties instance
+             */
             build(value: Flatten): TeamProperties;
         }
+        /**
+         * Singleton builder instance for TeamProperties.
+         */
         const builder: TypeBuilder;
     }
+    /**
+     * Flattened representation of a User for serialization.
+     */
     type Flatten = {
         id: Id.Flatten;
         teams: Dictionary.Flatten<TeamProperties>;
     };
+    /**
+     * Builder for constructing User instances from flattened data.
+     */
     class TypeBuilder implements ITypeBuilder<Flatten, User> {
+        /**
+         * Builds a User instance from flattened data.
+         * @param value - The flattened user data
+         * @returns A new User instance with all teams reconstructed
+         */
         build(value: Flatten): User;
     }
+    /**
+     * Singleton builder instance for User.
+     */
     const builder: TypeBuilder;
 }

package/lib/src/types/User.js

@@ -4,13 +4,27 @@ exports.User = void 0;
 const typescript_common_functionality_1 = require("@stevenkellner/typescript-common-functionality");
 const Team_1 = require("./Team");
 const Person_1 = require("./Person");
+/**
+ * Represents a user in the system with associated team memberships.
+ *
+ * A user can be a member of multiple teams, and for each team, they have
+ * specific properties (team name and associated person ID).
+ */
 class User {
     id;
     teams;
+    /**
+     * Creates a new User instance.
+     * @param id - The unique identifier for this user
+     * @param teams - Dictionary mapping team IDs to team-specific user properties
+     */
     constructor(id, teams = new typescript_common_functionality_1.Dictionary(Team_1.Team.Id.builder)) {
         this.id = id;
         this.teams = teams;
     }
+    /**
+     * Gets the flattened representation of this user for serialization.
+     */
     get flatten() {
         return {
             id: this.id.flatten,
@@ -22,37 +36,77 @@ exports.User = User;
 (function (User) {
     let Id;
     (function (Id) {
+        /**
+         * Builder for constructing User.Id instances from strings.
+         */
         Id.builder = typescript_common_functionality_1.Tagged.builder('user', new typescript_common_functionality_1.ValueTypeBuilder());
     })(Id = User.Id || (User.Id = {}));
+    /**
+     * Properties that are specific to a user's membership in a particular team.
+     */
     class TeamProperties {
-        name;
+        teamId;
+        teamName;
         personId;
-        constructor(name, personId) {
-            this.name = name;
+        /**
+         * Creates new team-specific user properties.
+         * @param teamId - The ID of the team
+         * @param teamName - The display name of the team
+         * @param personId - The ID of the person associated with this user in this team
+         */
+        constructor(teamId, teamName, personId) {
+            this.teamId = teamId;
+            this.teamName = teamName;
             this.personId = personId;
         }
+        /**
+         * Gets the flattened representation of these team properties.
+         */
         get flatten() {
             return {
-                name: this.name,
+                teamId: this.teamId.flatten,
+                teamName: this.teamName,
                 personId: this.personId.flatten
             };
         }
     }
     User.TeamProperties = TeamProperties;
     (function (TeamProperties) {
+        /**
+         * Builder for constructing TeamProperties from flattened data.
+         */
         class TypeBuilder {
+            /**
+             * Builds a TeamProperties instance from flattened data.
+             * @param value - The flattened team properties data
+             * @returns A new TeamProperties instance
+             */
             build(value) {
-                return new TeamProperties(value.name, Person_1.Person.Id.builder.build(value.personId));
+                return new TeamProperties(Team_1.Team.Id.builder.build(value.teamId), value.teamName, Person_1.Person.Id.builder.build(value.personId));
             }
         }
         TeamProperties.TypeBuilder = TypeBuilder;
+        /**
+         * Singleton builder instance for TeamProperties.
+         */
         TeamProperties.builder = new TypeBuilder();
     })(TeamProperties = User.TeamProperties || (User.TeamProperties = {}));
+    /**
+     * Builder for constructing User instances from flattened data.
+     */
     class TypeBuilder {
+        /**
+         * Builds a User instance from flattened data.
+         * @param value - The flattened user data
+         * @returns A new User instance with all teams reconstructed
+         */
         build(value) {
             return new User(Id.builder.build(value.id), typescript_common_functionality_1.Dictionary.builder(Team_1.Team.Id.builder, User.TeamProperties.builder).build(value.teams));
         }
     }
     User.TypeBuilder = TypeBuilder;
+    /**
+     * Singleton builder instance for User.
+     */
     User.builder = new TypeBuilder();
 })(User || (exports.User = User = {}));

package/lib/src/types/UserRole.d.ts

@@ -1,7 +1,29 @@
 import { ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
-export type UserRole = 'person-manager' | 'fineTemplate-manager' | 'fine-manager' | 'fine-can-add' | 'team-manager';
+import { Locale } from './Locale';
+/**
+ * Array of all available user roles.
+ */
+declare const userRoles: readonly ["person-manager", "fineTemplate-manager", "fine-manager", "fine-can-add", "team-manager"];
+/**
+ * Represents user roles in the application.
+ * Defines different levels of permissions for team members.
+ */
+export type UserRole = typeof userRoles[number];
 export declare namespace UserRole {
-    const all: UserRole[];
-    function formatted(role: UserRole): string;
-    const builder: ValueTypeBuilder<UserRole>;
+    /**
+     * Array of all available user roles.
+     */
+    const all: readonly UserRole[];
+    /**
+     * Returns the localized, human-readable name for a user role.
+     * @param role - The user role to format
+     * @param locale - The locale to use for localization
+     * @returns The localized role name
+     */
+    function formatted(role: UserRole, locale: Locale): string;
+    /**
+     * Builder for constructing UserRole values.
+     */
+    const builder: ValueTypeBuilder<"person-manager" | "fineTemplate-manager" | "fine-manager" | "fine-can-add" | "team-manager">;
 }
+export {};

package/lib/src/types/UserRole.js

@@ -3,16 +3,29 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.UserRole = void 0;
 const typescript_common_functionality_1 = require("@stevenkellner/typescript-common-functionality");
 const Localization_1 = require("./Localization");
+/**
+ * Array of all available user roles.
+ */
+const userRoles = [
+    'person-manager', // Can manage persons, i.e. add/edit/remove persons of the team
+    'fineTemplate-manager', // Can manage fine templates, i.e. add/edit/remove fine templates
+    'fine-manager', // Can manage fines, i.e. add/edit/remove fines
+    'fine-can-add', // Can add fines, but not edit or remove them
+    'team-manager' // Can manage team settings, i.e. invite/remove team members, change team name, etc.
+];
 var UserRole;
 (function (UserRole) {
-    UserRole.all = [
-        'person-manager',
-        'fineTemplate-manager',
-        'fine-manager',
-        'fine-can-add',
-        'team-manager'
-    ];
-    function formatted(role) {
+    /**
+     * Array of all available user roles.
+     */
+    UserRole.all = userRoles;
+    /**
+     * Returns the localized, human-readable name for a user role.
+     * @param role - The user role to format
+     * @param locale - The locale to use for localization
+     * @returns The localized role name
+     */
+    function formatted(role, locale) {
         const localizationKeyMap = {
             'person-manager': 'personManager',
             'fineTemplate-manager': 'fineTemplateManager',
@@ -20,8 +33,11 @@ var UserRole;
             'fine-can-add': 'fineCanAdd',
             'team-manager': 'teamManager'
         };
-        return Localization_1.Localization.shared.userRole[localizationKeyMap[role]].value();
+        return Localization_1.Localization.shared(locale).userRole[localizationKeyMap[role]].value();
     }
     UserRole.formatted = formatted;
+    /**
+     * Builder for constructing UserRole values.
+     */
     UserRole.builder = new typescript_common_functionality_1.ValueTypeBuilder();
 })(UserRole || (exports.UserRole = UserRole = {}));

package/lib/src/types/index.d.ts

@@ -15,3 +15,5 @@ export * from './Pluralization';
 export * from './Team';
 export * from './User';
 export * from './UserRole';
+export * from './Currency';
+export * from './Locale';

package/lib/src/types/index.js

@@ -31,3 +31,5 @@ __exportStar(require("./Pluralization"), exports);
 __exportStar(require("./Team"), exports);
 __exportStar(require("./User"), exports);
 __exportStar(require("./UserRole"), exports);
+__exportStar(require("./Currency"), exports);
+__exportStar(require("./Locale"), exports);

package/lib/test/firebase/FirebaseConfiguration.test.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@assertive-ts/core");
+const FirebaseConfiguration_1 = require("../../src/firebase/FirebaseConfiguration");
+describe('FirebaseConfiguration', () => {
+    describe('FirebaseConfiguration.shared', () => {
+        it('should return a singleton instance', () => {
+            const instance1 = FirebaseConfiguration_1.FirebaseConfiguration.shared;
+            const instance2 = FirebaseConfiguration_1.FirebaseConfiguration.shared;
+            (0, core_1.expect)(instance1).toBeEqual(instance2);
+        });
+        it('should be an instance of FirebaseConfiguration', () => {
+            const instance = FirebaseConfiguration_1.FirebaseConfiguration.shared;
+            (0, core_1.expect)(instance instanceof FirebaseConfiguration_1.FirebaseConfiguration).toBeTrue();
+        });
+    });
+    describe('FirebaseConfiguration.configure', () => {
+        // Note: Since FirebaseConfiguration is a singleton and maintains state,
+        // we need to be careful with testing. In a real-world scenario, you might
+        // need to add a reset method for testing purposes or use dependency injection.
+        // For now, we'll test the error cases that don't require full configuration.
+        it('should throw error when configuring twice', () => {
+            // Create a mock configuration
+            const mockFirestore = {};
+            const mockMessaging = {
+                sendEachForMulticast: async () => ({
+                    responses: [],
+                    successCount: 0,
+                    failureCount: 0
+                })
+            };
+            // We can't actually configure the shared instance in tests without affecting other tests
+            // This test documents the expected behavior
+            (0, core_1.expect)(() => {
+                // If already configured, this should throw
+                try {
+                    FirebaseConfiguration_1.FirebaseConfiguration.shared.configure({
+                        baseFirestoreDocument: mockFirestore,
+                        messaging: mockMessaging
+                    });
+                    // If it succeeds, try configuring again to test the double-configuration error
+                    FirebaseConfiguration_1.FirebaseConfiguration.shared.configure({
+                        baseFirestoreDocument: mockFirestore,
+                        messaging: mockMessaging
+                    });
+                }
+                catch (error) {
+                    if (error instanceof Error && error.message === 'Configuration is already configured')
+                        throw error;
+                    // If it's the "not configured" error, the first configure worked
+                    // but we can't test double-configuration in this test environment
+                }
+            }).toThrow();
+        });
+    });
+    describe('FirebaseConfiguration getters', () => {
+        describe('baseFirestoreDocument', () => {
+            it('should throw error when not configured', () => {
+                // Create a fresh test to check unconfigured state
+                // Note: In practice, the shared instance might already be configured
+                try {
+                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                    const _ = FirebaseConfiguration_1.FirebaseConfiguration.shared.baseFirestoreDocument;
+                    // If we get here, it was already configured (expected in normal operation)
+                }
+                catch (error) {
+                    (0, core_1.expect)(error instanceof Error).toBeTrue();
+                    if (error instanceof Error)
+                        (0, core_1.expect)(error.message).toBeEqual('Configuration.baseFirestoreDocument is not configured');
+                }
+            });
+        });
+        describe('messaging', () => {
+            it('should throw error when not configured', () => {
+                // Create a fresh test to check unconfigured state
+                try {
+                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                    const _ = FirebaseConfiguration_1.FirebaseConfiguration.shared.messaging;
+                    // If we get here, it was already configured (expected in normal operation)
+                }
+                catch (error) {
+                    (0, core_1.expect)(error instanceof Error).toBeTrue();
+                    if (error instanceof Error)
+                        (0, core_1.expect)(error.message).toBeEqual('Configuration.messaging is not configured');
+                }
+            });
+        });
+    });
+    describe('FirebaseConfiguration behavior', () => {
+        it('should maintain singleton pattern', () => {
+            const instance = FirebaseConfiguration_1.FirebaseConfiguration.shared;
+            (0, core_1.expect)(instance).not.toBeNull();
+            (0, core_1.expect)(instance).not.toBeUndefined();
+        });
+        it('should have configure method', () => {
+            (0, core_1.expect)(typeof FirebaseConfiguration_1.FirebaseConfiguration.shared.configure).toBeEqual('function');
+        });
+        it('should have baseFirestoreDocument getter', () => {
+            const descriptor = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(FirebaseConfiguration_1.FirebaseConfiguration.shared), 'baseFirestoreDocument');
+            (0, core_1.expect)(descriptor).not.toBeEqual(undefined);
+            (0, core_1.expect)(descriptor?.get).not.toBeEqual(undefined);
+        });
+        it('should have messaging getter', () => {
+            const descriptor = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(FirebaseConfiguration_1.FirebaseConfiguration.shared), 'messaging');
+            (0, core_1.expect)(descriptor).not.toBeEqual(undefined);
+            (0, core_1.expect)(descriptor?.get).not.toBeEqual(undefined);
+        });
+    });
+    describe('FirebaseConfiguration configuration object', () => {
+        it('should accept valid configuration structure', () => {
+            const mockFirestore = {};
+            const mockMessaging = {
+                sendEachForMulticast: async () => ({
+                    responses: [],
+                    successCount: 0,
+                    failureCount: 0
+                })
+            };
+            const configuration = {
+                baseFirestoreDocument: mockFirestore,
+                messaging: mockMessaging
+            };
+            (0, core_1.expect)(configuration.baseFirestoreDocument).toBeEqual(mockFirestore);
+            (0, core_1.expect)(configuration.messaging).toBeEqual(mockMessaging);
+        });
+        it('should require baseFirestoreDocument in configuration', () => {
+            const mockMessaging = {
+                sendEachForMulticast: async () => ({
+                    responses: [],
+                    successCount: 0,
+                    failureCount: 0
+                })
+            };
+            const configuration = {
+                baseFirestoreDocument: {},
+                messaging: mockMessaging
+            };
+            (0, core_1.expect)(configuration.baseFirestoreDocument).not.toBeUndefined();
+        });
+        it('should require messaging in configuration', () => {
+            const mockFirestore = {};
+            const configuration = {
+                baseFirestoreDocument: mockFirestore,
+                messaging: {
+                    sendEachForMulticast: async () => ({
+                        responses: [],
+                        successCount: 0,
+                        failureCount: 0
+                    })
+                }
+            };
+            (0, core_1.expect)(configuration.messaging).not.toBeUndefined();
+        });
+    });
+});

package/lib/test/firebase/Firestore.test.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@assertive-ts/core");
+const Firestore_1 = require("../../src/firebase/Firestore");
+describe('Firestore', () => {
+    describe('shared singleton', () => {
+        it('should return the same instance on multiple calls', () => {
+            const instance1 = Firestore_1.Firestore.shared;
+            const instance2 = Firestore_1.Firestore.shared;
+            (0, core_1.expect)(instance1).toBe(instance2);
+        });
+        it('should create an instance', () => {
+            const instance = Firestore_1.Firestore.shared;
+            (0, core_1.expect)(instance).toBeInstanceOf(Firestore_1.Firestore);
+        });
+    });
+    describe('accessor methods', () => {
+        it('should have team method', () => {
+            (0, core_1.expect)(typeof Firestore_1.Firestore.shared.team).toBeEqual('function');
+        });
+        it('should have user method', () => {
+            (0, core_1.expect)(typeof Firestore_1.Firestore.shared.user).toBeEqual('function');
+        });
+        it('should have invitation method', () => {
+            (0, core_1.expect)(typeof Firestore_1.Firestore.shared.invitation).toBeEqual('function');
+        });
+        it('should have persons method', () => {
+            (0, core_1.expect)(typeof Firestore_1.Firestore.shared.persons).toBeEqual('function');
+        });
+        it('should have person method', () => {
+            (0, core_1.expect)(typeof Firestore_1.Firestore.shared.person).toBeEqual('function');
+        });
+        it('should have fineTemplates method', () => {
+            (0, core_1.expect)(typeof Firestore_1.Firestore.shared.fineTemplates).toBeEqual('function');
+        });
+        it('should have fineTemplate method', () => {
+            (0, core_1.expect)(typeof Firestore_1.Firestore.shared.fineTemplate).toBeEqual('function');
+        });
+        it('should have fines method', () => {
+            (0, core_1.expect)(typeof Firestore_1.Firestore.shared.fines).toBeEqual('function');
+        });
+        it('should have fine method', () => {
+            (0, core_1.expect)(typeof Firestore_1.Firestore.shared.fine).toBeEqual('function');
+        });
+    });
+});

package/lib/test/firebase/checkAuthentication.test.d.ts

@@ -0,0 +1 @@
+export {};