academe-kit 0.1.9 → 0.2.2

package/dist/types/context/SecurityProvider/types.d.ts

@@ -1,5 +1,6 @@
-import { KeycloakLoginOptions, KeycloakPromise } from 'keycloak-js';
-import { MongoDBUser } from '../../services/userService';
+import { KeycloakLoginOptions } from 'keycloak-js';
+import { User } from '../../types';
+import { AcademeApiClient, AcademeServices } from '../../services';
 export type AcademeKeycloakContextProps = {
     realm: string;
     hubUrl: string;
@@ -18,17 +19,19 @@ export type KeycloakUser = {
     lastName: string;
     email: string;
 };
-export type AcademeUser = MongoDBUser & {
+export type AcademeUser = User & {
     keycloakUser?: KeycloakUser;
 };
 export type SecurityContextType = {
     isInitialized: boolean;
     isAuthenticated: () => boolean;
     signOut: () => void | null;
-    goToLogin: (options?: KeycloakLoginOptions | undefined) => KeycloakPromise<void, void> | null;
+    goToLogin: (options?: KeycloakLoginOptions | undefined) => void;
     user: AcademeUser | null;
     refreshUserData: () => Promise<void>;
     hasRealmRole: (role: string) => boolean;
     hasSchool: (schoolId: string) => boolean;
     hasClientRole: (role: string, resource?: string) => boolean;
+    apiClient: AcademeApiClient | null;
+    services: AcademeServices | null;
 };

package/dist/types/index.d.ts

@@ -5,9 +5,14 @@ export { ProtectedComponent } from './components/ProtectedComponent';
 export { ProtectedRouter } from './components/ProtectedRouter';
 export { Spinner } from './components/ui/spinner';
 export { AcademeAuthProvider, useAcademeAuth } from './context/SecurityProvider';
-export { createUserService } from './services/userService';
-export type { MongoDBUser, UserServiceConfig } from './services/userService';
 export type { AcademeKeycloakContextProps, SecurityProviderProps, KeycloakUser, SecurityContextType, AcademeUser, } from './context/SecurityProvider/types';
+export { createAcademeApiClient } from './services';
+export type { AcademeApiClient } from './services';
 export { cn } from './lib/utils';
 import './index.css';
 import './styles/globals.css';
+export { GLOBAL_ROLES } from './roles/global';
+export { BACKOFFICE_ROLES } from './roles/backoffice';
+export { DASHBOARD_ROLES } from './roles/dashboard';
+export * as types from './types';
+export * as apiTypes from './types/academe-api';

package/dist/types/roles/backoffice.d.ts

@@ -0,0 +1,2 @@
+export declare enum BACKOFFICE_ROLES {
+}

package/dist/types/roles/dashboard.d.ts

@@ -0,0 +1,2 @@
+export declare enum DASHBOARD_ROLES {
+}

package/dist/types/roles/global.d.ts

@@ -0,0 +1,7 @@
+export declare enum GLOBAL_ROLES {
+    ADMIN_ACADEME = "admin_academe",
+    SCHOOL_ADMIN = "school_admin",
+    TEACHER = "teacher",
+    STUDENT = "student",
+    GUARDIAN = "guardian"
+}

package/dist/types/services/ClassroomService.d.ts

@@ -0,0 +1,270 @@
+import type { AcademeApiClient } from './index';
+import type { components } from '../types/academe-api';
+type CreateClassroomDto = components['schemas']['CreateClassroomDto'];
+type UpdateClassroomDto = components['schemas']['UpdateClassroomDto'];
+type GetClassroomsByInstitutionParams = {
+    page?: number;
+    limit?: number;
+    search?: string;
+};
+export declare function createClassroomService(apiClient: AcademeApiClient): {
+    /**
+     * List all classrooms
+     */
+    getAll(): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: components["schemas"]["Classroom"][];
+                    };
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            500: components["responses"]["ServerError"];
+        };
+    }, import("openapi-fetch").FetchOptions<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: components["schemas"]["Classroom"][];
+                    };
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            500: components["responses"]["ServerError"];
+        };
+    }> | undefined, `${string}/${string}`>>;
+    /**
+     * Get classroom by ID
+     */
+    getById(id: string): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["id"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: components["schemas"]["Classroom"];
+                    };
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            500: components["responses"]["ServerError"];
+        };
+    }, {
+        params: {
+            path: {
+                id: string;
+            };
+        };
+    }, `${string}/${string}`>>;
+    /**
+     * Get classrooms by institution ID
+     */
+    getByInstitution(institutionId: string, params?: GetClassroomsByInstitutionParams): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: {
+                page?: number;
+                limit?: number;
+                search?: string;
+            };
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: components["schemas"]["Classroom"][];
+                        meta?: {
+                            total?: number;
+                            page?: number;
+                            limit?: number;
+                            totalPages?: number;
+                        };
+                    };
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            500: components["responses"]["ServerError"];
+        };
+    }, {
+        params: {
+            path: {
+                id: string;
+            };
+            query: GetClassroomsByInstitutionParams | undefined;
+        };
+    }, `${string}/${string}`>>;
+    /**
+     * Create a new classroom
+     */
+    create(data: CreateClassroomDto): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateClassroomDto"];
+            };
+        };
+        responses: {
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: components["schemas"]["Classroom"];
+                        message?: string;
+                    };
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            500: components["responses"]["ServerError"];
+        };
+    }, {
+        body: {
+            name: string;
+            shiftId: string;
+            serieId: string;
+        };
+    }, `${string}/${string}`>>;
+    /**
+     * Update classroom
+     */
+    update(id: string, data: UpdateClassroomDto): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["id"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["UpdateClassroomDto"];
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: components["schemas"]["Classroom"];
+                        message?: string;
+                    };
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            500: components["responses"]["ServerError"];
+        };
+    }, {
+        params: {
+            path: {
+                id: string;
+            };
+        };
+        body: {
+            name?: string;
+            shiftId?: string;
+            serieId?: string;
+        };
+    }, `${string}/${string}`>>;
+    /**
+     * Delete classroom
+     */
+    delete(id: string): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["id"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        message?: string;
+                    };
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            500: components["responses"]["ServerError"];
+        };
+    }, {
+        params: {
+            path: {
+                id: string;
+            };
+        };
+    }, `${string}/${string}`>>;
+};
+export type ClassroomService = ReturnType<typeof createClassroomService>;
+export {};

package/dist/types/services/GuardianService.d.ts

@@ -0,0 +1,309 @@
+import type { AcademeApiClient } from './index';
+import type { components } from '../types/academe-api';
+type CreateGuardianDto = components['schemas']['CreateGuardianDto'];
+type UpdateGuardianDto = components['schemas']['UpdateGuardianDto'];
+type AssignGuardianToUserDto = components['schemas']['AssignGuardianToUserDto'];
+export declare function createGuardianService(apiClient: AcademeApiClient): {
+    getAll(): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: components["schemas"]["Guardian"][];
+                    };
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            500: components["responses"]["ServerError"];
+        };
+    }, import("openapi-fetch").FetchOptions<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: components["schemas"]["Guardian"][];
+                    };
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            500: components["responses"]["ServerError"];
+        };
+    }> | undefined, `${string}/${string}`>>;
+    getById(id: string): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["id"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: components["schemas"]["Guardian"];
+                    };
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            500: components["responses"]["ServerError"];
+        };
+    }, {
+        params: {
+            path: {
+                id: string;
+            };
+        };
+    }, `${string}/${string}`>>;
+    create(data: CreateGuardianDto): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateGuardianDto"];
+            };
+        };
+        responses: {
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: components["schemas"]["Guardian"];
+                        message?: string;
+                    };
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            500: components["responses"]["ServerError"];
+        };
+    }, {
+        body: {
+            email: string;
+            phone?: string;
+            name: string;
+        };
+    }, `${string}/${string}`>>;
+    update(id: string, data: UpdateGuardianDto): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["id"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["UpdateGuardianDto"];
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: components["schemas"]["Guardian"];
+                        message?: string;
+                    };
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            500: components["responses"]["ServerError"];
+        };
+    }, {
+        params: {
+            path: {
+                id: string;
+            };
+        };
+        body: {
+            email?: string;
+            phone?: string;
+            name?: string;
+        };
+    }, `${string}/${string}`>>;
+    delete(id: string): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["id"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        message?: string;
+                    };
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            500: components["responses"]["ServerError"];
+        };
+    }, {
+        params: {
+            path: {
+                id: string;
+            };
+        };
+    }, `${string}/${string}`>>;
+    getUsers(id: string): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["id"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        data?: components["schemas"]["User"][];
+                    };
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            500: components["responses"]["ServerError"];
+        };
+    }, {
+        params: {
+            path: {
+                id: string;
+            };
+        };
+    }, `${string}/${string}`>>;
+    assignToUser(data: AssignGuardianToUserDto): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["AssignGuardianToUserDto"];
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        message?: string;
+                    };
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            500: components["responses"]["ServerError"];
+        };
+    }, {
+        body: {
+            userId: string;
+            guardianId: string;
+        };
+    }, `${string}/${string}`>>;
+    removeFromUser(guardianId: string, userId: string): Promise<import("openapi-fetch").FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                guardianId: string;
+                userId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        status?: string;
+                        message?: string;
+                    };
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            500: components["responses"]["ServerError"];
+        };
+    }, {
+        params: {
+            path: {
+                guardianId: string;
+                userId: string;
+            };
+        };
+    }, `${string}/${string}`>>;
+};
+export type GuardianService = ReturnType<typeof createGuardianService>;
+export {};