@geniehr/utilities 1.0.5

package/dist/schema/files/person/emergencyContacts.d.ts

@@ -0,0 +1,23 @@
+import { z } from "zod";
+export declare const emergencyContactsSchema: z.ZodObject<{
+    employeeId: z.ZodNumber;
+    name: z.ZodString;
+    relationId: z.ZodNumber;
+    relationName: z.ZodString;
+    mobileNo: z.ZodOptional<z.ZodString>;
+    emailAddress: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    employeeId: number;
+    name: string;
+    relationId: number;
+    relationName: string;
+    mobileNo?: string | undefined;
+    emailAddress?: string | undefined;
+}, {
+    employeeId: number;
+    name: string;
+    relationId: number;
+    relationName: string;
+    mobileNo?: string | undefined;
+    emailAddress?: string | undefined;
+}>;

package/dist/schema/files/person/emergencyContacts.js

@@ -0,0 +1,9 @@
+import { z } from "zod";
+export const emergencyContactsSchema = z.object({
+    employeeId: z.number().int(),
+    name: z.string().trim().min(1).max(100),
+    relationId: z.number().int(),
+    relationName: z.string().trim().max(100),
+    mobileNo: z.string().trim().max(15).optional(),
+    emailAddress: z.string().trim().email().max(46).optional()
+});

package/dist/schema/files/person/index.d.ts

@@ -0,0 +1,7 @@
+export * from './personSchema.js';
+export * from './workDetails.js';
+export * from './pastExperiences.js';
+export * from './primaryContacts.js';
+export * from './emergencyContacts.js';
+export * from './qualifications.js';
+export * from './address.js';

package/dist/schema/files/person/index.js

@@ -0,0 +1,7 @@
+export * from './personSchema.js';
+export * from './workDetails.js';
+export * from './pastExperiences.js';
+export * from './primaryContacts.js';
+export * from './emergencyContacts.js';
+export * from './qualifications.js';
+export * from './address.js';

package/dist/schema/files/person/pastExperiences.d.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+export declare const pastExperiencesSchema: z.ZodObject<{
+    employeeId: z.ZodNumber;
+    company: z.ZodString;
+    location: z.ZodOptional<z.ZodString>;
+    role: z.ZodString;
+    duration: z.ZodOptional<z.ZodString>;
+    dateOfJoining: z.ZodOptional<z.ZodDate>;
+    dateOfLeaving: z.ZodOptional<z.ZodDate>;
+    lastDrawnCTC: z.ZodOptional<z.ZodNumber>;
+    reasonForLeaving: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    employeeId: number;
+    company: string;
+    role: string;
+    dateOfJoining?: Date | undefined;
+    location?: string | undefined;
+    duration?: string | undefined;
+    dateOfLeaving?: Date | undefined;
+    lastDrawnCTC?: number | undefined;
+    reasonForLeaving?: string | undefined;
+}, {
+    employeeId: number;
+    company: string;
+    role: string;
+    dateOfJoining?: Date | undefined;
+    location?: string | undefined;
+    duration?: string | undefined;
+    dateOfLeaving?: Date | undefined;
+    lastDrawnCTC?: number | undefined;
+    reasonForLeaving?: string | undefined;
+}>;

package/dist/schema/files/person/pastExperiences.js

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+export const pastExperiencesSchema = z.object({
+    employeeId: z.number().int(),
+    company: z.string().trim().min(1).max(100),
+    location: z.string().trim().max(100).optional(),
+    role: z.string().trim().min(1).max(100),
+    duration: z.string().trim().max(50).optional(),
+    dateOfJoining: z.coerce.date().optional(),
+    dateOfLeaving: z.coerce.date().optional(),
+    lastDrawnCTC: z.coerce.number().optional(),
+    reasonForLeaving: z.string().trim().optional()
+});

package/dist/schema/files/person/personSchema.d.ts

@@ -0,0 +1,59 @@
+import { z } from "zod";
+export declare const personSchema: z.ZodObject<{
+    firstName: z.ZodString;
+    middleName: z.ZodOptional<z.ZodString>;
+    lastName: z.ZodOptional<z.ZodString>;
+    dateOfBirth: z.ZodOptional<z.ZodDate>;
+    genderId: z.ZodOptional<z.ZodNumber>;
+    genderName: z.ZodOptional<z.ZodString>;
+    bloodGroupId: z.ZodOptional<z.ZodNumber>;
+    bloodGroupName: z.ZodOptional<z.ZodString>;
+    maritalStatus: z.ZodOptional<z.ZodString>;
+    maritalStatusId: z.ZodOptional<z.ZodNumber>;
+    mobileNo: z.ZodOptional<z.ZodString>;
+    emailAddress: z.ZodOptional<z.ZodString>;
+    about: z.ZodOptional<z.ZodString>;
+    iamId: z.ZodOptional<z.ZodString>;
+    employeeNo: z.ZodOptional<z.ZodString>;
+    ghrId: z.ZodNumber;
+    personTypeId: z.ZodNumber;
+    personTypeName: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    firstName: string;
+    ghrId: number;
+    personTypeId: number;
+    personTypeName: string;
+    middleName?: string | undefined;
+    lastName?: string | undefined;
+    dateOfBirth?: Date | undefined;
+    genderId?: number | undefined;
+    genderName?: string | undefined;
+    bloodGroupId?: number | undefined;
+    bloodGroupName?: string | undefined;
+    maritalStatus?: string | undefined;
+    maritalStatusId?: number | undefined;
+    mobileNo?: string | undefined;
+    emailAddress?: string | undefined;
+    about?: string | undefined;
+    iamId?: string | undefined;
+    employeeNo?: string | undefined;
+}, {
+    firstName: string;
+    ghrId: number;
+    personTypeId: number;
+    personTypeName: string;
+    middleName?: string | undefined;
+    lastName?: string | undefined;
+    dateOfBirth?: Date | undefined;
+    genderId?: number | undefined;
+    genderName?: string | undefined;
+    bloodGroupId?: number | undefined;
+    bloodGroupName?: string | undefined;
+    maritalStatus?: string | undefined;
+    maritalStatusId?: number | undefined;
+    mobileNo?: string | undefined;
+    emailAddress?: string | undefined;
+    about?: string | undefined;
+    iamId?: string | undefined;
+    employeeNo?: string | undefined;
+}>;

package/dist/schema/files/person/personSchema.js

@@ -0,0 +1,21 @@
+import { z } from "zod";
+export const personSchema = z.object({
+    firstName: z.string().trim().min(1).max(45),
+    middleName: z.string().trim().max(45).optional(),
+    lastName: z.string().trim().max(45).optional(),
+    dateOfBirth: z.coerce.date().optional(),
+    genderId: z.number().int().optional(),
+    genderName: z.string().trim().max(100).optional(),
+    bloodGroupId: z.number().int().optional(),
+    bloodGroupName: z.string().trim().max(100).optional(),
+    maritalStatus: z.string().trim().max(20).optional(),
+    maritalStatusId: z.number().int().optional(),
+    mobileNo: z.string().trim().max(15).optional(),
+    emailAddress: z.string().trim().email().max(46).optional(),
+    about: z.string().trim().optional(),
+    iamId: z.string().trim().max(50).optional(),
+    employeeNo: z.string().trim().max(45).optional(),
+    ghrId: z.number().int(),
+    personTypeId: z.number().int(),
+    personTypeName: z.string().trim().max(100)
+});

package/dist/schema/files/person/primaryContacts.d.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+export declare const primaryContactsSchema: z.ZodObject<{
+    employeeId: z.ZodNumber;
+    name: z.ZodString;
+    relationId: z.ZodNumber;
+    relationName: z.ZodString;
+    mobileNo: z.ZodOptional<z.ZodString>;
+    emailAddress: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    employeeId: number;
+    name: string;
+    relationId: number;
+    relationName: string;
+    mobileNo?: string | undefined;
+    emailAddress?: string | undefined;
+}, {
+    employeeId: number;
+    name: string;
+    relationId: number;
+    relationName: string;
+    mobileNo?: string | undefined;
+    emailAddress?: string | undefined;
+}>;

package/dist/schema/files/person/primaryContacts.js

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export const primaryContactsSchema = z.object({
+    employeeId: z.number().int(),
+    name: z.string().trim().min(1).max(100),
+    relationId: z.number().int(),
+    relationName: z.string().trim().max(100),
+    mobileNo: z.string().trim().max(15).optional(),
+    emailAddress: z.string().trim().email().max(46).optional()
+});

package/dist/schema/files/person/qualifications.d.ts

@@ -0,0 +1,35 @@
+import { z } from "zod";
+export declare const qualificationsSchema: z.ZodObject<{
+    employeeId: z.ZodNumber;
+    institution: z.ZodString;
+    year: z.ZodNumber;
+    percentage: z.ZodNumber;
+    courseId: z.ZodNumber;
+    specializationId: z.ZodNumber;
+    courseName: z.ZodString;
+    specializationName: z.ZodString;
+    qualification: z.ZodOptional<z.ZodString>;
+    qualificationId: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    employeeId: number;
+    institution: string;
+    year: number;
+    percentage: number;
+    courseId: number;
+    specializationId: number;
+    courseName: string;
+    specializationName: string;
+    qualification?: string | undefined;
+    qualificationId?: number | undefined;
+}, {
+    employeeId: number;
+    institution: string;
+    year: number;
+    percentage: number;
+    courseId: number;
+    specializationId: number;
+    courseName: string;
+    specializationName: string;
+    qualification?: string | undefined;
+    qualificationId?: number | undefined;
+}>;

package/dist/schema/files/person/qualifications.js

@@ -0,0 +1,13 @@
+import { z } from "zod";
+export const qualificationsSchema = z.object({
+    employeeId: z.number().int(),
+    institution: z.string().trim().min(1).max(150),
+    year: z.number().int(),
+    percentage: z.number(),
+    courseId: z.number().int(),
+    specializationId: z.number().int(),
+    courseName: z.string().trim().min(1).max(100),
+    specializationName: z.string().trim().min(1).max(100),
+    qualification: z.string().trim().max(100).optional(),
+    qualificationId: z.number().int().optional()
+});

package/dist/schema/files/person/workDetails.d.ts

@@ -0,0 +1,53 @@
+import { z } from "zod";
+export declare const workDetailsSchema: z.ZodObject<{
+    employeeId: z.ZodNumber;
+    departmentId: z.ZodNumber;
+    designationId: z.ZodNumber;
+    dateOfJoining: z.ZodOptional<z.ZodDate>;
+    location: z.ZodString;
+    managerId: z.ZodOptional<z.ZodNumber>;
+    departmentName: z.ZodString;
+    designationName: z.ZodString;
+    managerName: z.ZodString;
+    functionalArea: z.ZodOptional<z.ZodString>;
+    functionalAreaId: z.ZodOptional<z.ZodNumber>;
+    industry: z.ZodOptional<z.ZodString>;
+    industryId: z.ZodOptional<z.ZodNumber>;
+    hrSpoc: z.ZodOptional<z.ZodString>;
+    employeeSkills: z.ZodOptional<z.ZodString>;
+    organization: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    employeeId: number;
+    departmentId: number;
+    designationId: number;
+    location: string;
+    departmentName: string;
+    designationName: string;
+    managerName: string;
+    dateOfJoining?: Date | undefined;
+    managerId?: number | undefined;
+    functionalArea?: string | undefined;
+    functionalAreaId?: number | undefined;
+    industry?: string | undefined;
+    industryId?: number | undefined;
+    hrSpoc?: string | undefined;
+    employeeSkills?: string | undefined;
+    organization?: string | undefined;
+}, {
+    employeeId: number;
+    departmentId: number;
+    designationId: number;
+    location: string;
+    departmentName: string;
+    designationName: string;
+    managerName: string;
+    dateOfJoining?: Date | undefined;
+    managerId?: number | undefined;
+    functionalArea?: string | undefined;
+    functionalAreaId?: number | undefined;
+    industry?: string | undefined;
+    industryId?: number | undefined;
+    hrSpoc?: string | undefined;
+    employeeSkills?: string | undefined;
+    organization?: string | undefined;
+}>;

package/dist/schema/files/person/workDetails.js

@@ -0,0 +1,19 @@
+import { z } from "zod";
+export const workDetailsSchema = z.object({
+    employeeId: z.number().int(),
+    departmentId: z.number().int(),
+    designationId: z.number().int(),
+    dateOfJoining: z.coerce.date().optional(),
+    location: z.string().trim().max(100),
+    managerId: z.number().int().optional(),
+    departmentName: z.string().trim().max(100),
+    designationName: z.string().trim().max(100),
+    managerName: z.string().trim().max(100),
+    functionalArea: z.string().trim().max(200).optional(),
+    functionalAreaId: z.number().int().optional(),
+    industry: z.string().trim().max(100).optional(),
+    industryId: z.number().int().optional(),
+    hrSpoc: z.string().trim().max(100).optional(),
+    employeeSkills: z.string().trim().optional(),
+    organization: z.string().trim().max(100).optional()
+});

package/dist/schema/index.d.ts

@@ -0,0 +1 @@
+export { validateRequest } from './validation.js';

package/dist/schema/index.js

@@ -0,0 +1 @@
+export { validateRequest } from './validation.js';

package/dist/schema/schemaMappings.d.ts

@@ -0,0 +1,2 @@
+import { ZodTypeAny } from 'zod';
+export declare const mappings: Record<string, Record<string, Record<string, ZodTypeAny>>>;

package/dist/schema/schemaMappings.js

@@ -0,0 +1,25 @@
+import { emergencyContactsSchema, pastExperiencesSchema, personSchema, primaryContactsSchema, qualificationsSchema, workDetailsSchema, addressSchema } from './files/index.js';
+export const mappings = {
+    'people-ms': {
+        'post': {
+            '/people/person/profile': personSchema,
+            '/people/work/details': workDetailsSchema,
+            '/people/work/past-experience': pastExperiencesSchema,
+            '/people/contacts/primary': primaryContactsSchema,
+            '/people/contacts/emergency': emergencyContactsSchema,
+            '/people/education/qualification': qualificationsSchema,
+            '/people/person/address': addressSchema
+        }
+    },
+    'bff-ms': {
+        'post': {
+            '/api/employee/profile': personSchema,
+            '/api/employee/work/details': workDetailsSchema,
+            '/api/employee/work/past-experience': pastExperiencesSchema,
+            '/api/employee/contacts/primary': primaryContactsSchema,
+            '/api/employee/contacts/emergency': emergencyContactsSchema,
+            '/api/employee/education/qualification': qualificationsSchema,
+            '/api/employee/address': addressSchema
+        }
+    }
+};

package/dist/schema/validation.d.ts

@@ -0,0 +1,2 @@
+import { Request, Response, NextFunction } from 'express';
+export declare const validateRequest: (req: Request, res: Response, next: NextFunction) => void;

package/dist/schema/validation.js

@@ -0,0 +1,41 @@
+import { generateErrorMessage } from 'zod-error';
+import { getContext } from '../shared/context/index.js';
+import { mappings } from './schemaMappings.js';
+import { sendResponse } from '../apiUtils/api.js';
+import { HttpStatusCode } from '../shared/enums/HttpStatusCodes.js';
+import { InvalidRequestException } from '../shared/exceptions/index.js';
+const options = {
+    transform: (errorComponent) => `${errorComponent.issue.message} for ${errorComponent.issue.path.join('.')}`,
+};
+export const validateRequest = (req, res, next) => {
+    const schema = getSchema(req, res);
+    const service = getContext().service || '';
+    if (!schema) {
+        next();
+    }
+    else {
+        const result = schema.safeParse(req.body);
+        if (!result.success) {
+            const errorMessage = generateErrorMessage(result.error.issues, options);
+            sendResponse(req, res, HttpStatusCode.BAD_REQUEST, null, new InvalidRequestException(errorMessage.split("|"), "E-INVALID-REQUEST", {
+                service,
+                request: req.body,
+                params: req.params,
+                query: req.query,
+                path: req.originalUrl.split('?')[0],
+                method: req.method,
+                correlationId: res.getHeader('x-correlation-id')
+            }));
+        }
+        else {
+            next();
+        }
+    }
+};
+const getSchema = ((req, res) => {
+    const fullPath = req.originalUrl.split('?')[0];
+    const method = req.method.toLowerCase();
+    const service = getContext().service || '';
+    const schema = mappings?.[service]?.[method]?.[fullPath];
+    return schema;
+});

package/dist/secrets/CognitoUserService.d.ts

@@ -0,0 +1,28 @@
+export declare class CognitoUserService {
+    private client;
+    private userPoolId;
+    constructor(userPoolId: string);
+    /**
+     * Get user info from Cognito by username (email)
+     */
+    getUserInfo(email: string): Promise<{
+        username: string | undefined;
+        enabled: boolean | undefined;
+        userStatus: import("@aws-sdk/client-cognito-identity-provider").UserStatusType | undefined;
+        userCreateDate: Date | undefined;
+        userLastModifiedDate: Date | undefined;
+        attributes: Record<string, string>;
+    }>;
+    /**
+     * Create a new Cognito user
+     */
+    createUser(email: string, tempPassword: string, userAttributes?: Record<string, string>): Promise<import("@aws-sdk/client-cognito-identity-provider").AdminCreateUserCommandOutput>;
+    /**
+     * Update user attributes (like name, phone_number, etc.)
+     */
+    updateUserAttributes(email: string, attributes: Record<string, string>): Promise<import("@aws-sdk/client-cognito-identity-provider").AdminUpdateUserAttributesCommandOutput>;
+    deleteUser(username: string): Promise<{
+        message: string;
+        response: import("@aws-sdk/client-cognito-identity-provider").AdminDeleteUserCommandOutput;
+    }>;
+}

package/dist/secrets/CognitoUserService.js

@@ -0,0 +1,121 @@
+import { CognitoIdentityProviderClient, AdminCreateUserCommand, AdminUpdateUserAttributesCommand, AdminGetUserCommand, AdminDeleteUserCommand } from "@aws-sdk/client-cognito-identity-provider";
+import { fromIni } from "@aws-sdk/credential-providers";
+export class CognitoUserService {
+    client;
+    userPoolId;
+    constructor(userPoolId) {
+        this.userPoolId = userPoolId;
+        this.client = new CognitoIdentityProviderClient({
+            region: "ap-south-1",
+            credentials: process.env.NODE_ENV === "local" ? fromIni({ profile: "ghr-aws-dev-profile" }) : undefined
+        });
+    }
+    /**
+     * Get user info from Cognito by username (email)
+     */
+    async getUserInfo(email) {
+        try {
+            const params = {
+                UserPoolId: this.userPoolId,
+                Username: email,
+            };
+            const command = new AdminGetUserCommand(params);
+            const response = await this.client.send(command);
+            // Safely format attributes into key-value object
+            const attributes = response.UserAttributes?.reduce((acc, attr) => {
+                if (attr.Name) {
+                    acc[attr.Name] = attr.Value ?? "";
+                }
+                return acc;
+            }, {}) || {};
+            return {
+                username: response.Username,
+                enabled: response.Enabled,
+                userStatus: response.UserStatus,
+                userCreateDate: response.UserCreateDate,
+                userLastModifiedDate: response.UserLastModifiedDate,
+                attributes,
+            };
+        }
+        catch (error) {
+            console.error("Error fetching Cognito user info:", error);
+            throw error;
+        }
+    }
+    /**
+     * Create a new Cognito user
+     */
+    async createUser(email, tempPassword, userAttributes = {}) {
+        try {
+            const params = {
+                UserPoolId: this.userPoolId,
+                Username: email,
+                TemporaryPassword: tempPassword,
+                UserAttributes: Object.entries(userAttributes).map(([Name, Value]) => ({ Name, Value })),
+                MessageAction: "SUPPRESS", // Avoid sending default Cognito email
+            };
+            const command = new AdminCreateUserCommand(params);
+            const response = await this.client.send(command);
+            return response;
+        }
+        catch (error) {
+            console.error("Error creating Cognito user:", error);
+            throw error;
+        }
+    }
+    /**
+     * Update user attributes (like name, phone_number, etc.)
+     */
+    async updateUserAttributes(email, attributes) {
+        try {
+            const params = {
+                UserPoolId: this.userPoolId,
+                Username: email,
+                UserAttributes: Object.entries(attributes).map(([Name, Value]) => ({ Name, Value })),
+            };
+            const command = new AdminUpdateUserAttributesCommand(params);
+            const response = await this.client.send(command);
+            return response;
+        }
+        catch (error) {
+            console.error("Error updating Cognito user attributes:", error);
+            throw error;
+        }
+    }
+    async deleteUser(username) {
+        try {
+            const params = {
+                UserPoolId: this.userPoolId,
+                Username: username,
+            };
+            const command = new AdminDeleteUserCommand(params);
+            const response = await this.client.send(command);
+            return {
+                message: `User '${username}' deleted successfully`,
+                response,
+            };
+        }
+        catch (error) {
+            console.error("Error deleting Cognito user:", error);
+            throw error;
+        }
+    }
+}
+/*
+(async () => {
+  const userPoolId = "ap-south-1_examplePoolId"; // replace with your actual Cognito User Pool ID
+  const cognitoService = new CognitoUserService(userPoolId);
+
+  // Create user
+  await cognitoService.createUser("user@example.com", "Temp@123", {
+    email: "user@example.com",
+    name: "Deepak Parab",
+  });
+
+  // Update user
+  await cognitoService.updateUserAttributes("user@example.com", {
+    name: "Deepak P.",
+    phone_number: "+919999999999",
+  });
+})();
+*/ 

package/dist/secrets/aws.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Fetch a single parameter or all parameters under a prefix.
+ * @param nameOrPrefix Full name (e.g. /dev/mysql/person) or prefix (e.g. /dev/mysql/)
+ */
+export declare function getAWSParameters(nameOrPrefix: string): Promise<Record<string, string>>;
+export declare function matchFace(imageInBase64: string): Promise<import("@aws-sdk/client-rekognition").SearchFacesByImageCommandOutput>;
+export declare function registerFace(employeeId: string, imageInBase64: string): Promise<import("@aws-sdk/client-rekognition").IndexFacesCommandOutput>;
+export declare function generatePresignedUrl(entity: string, fileName: string, bucketName: string, idToken: string, action: 'put' | 'get', expiresIn?: number): Promise<string>;
+export declare function executeS3Action(action: "put" | "get", bucketName: string, key: string, body?: Buffer, contentType?: string): Promise<import("@aws-sdk/client-s3").PutObjectCommandOutput>;
+export declare function updateCustomAttribute(username: string, userPoolId: string, attributeName: string, attributeValue: string): Promise<{
+    success: boolean;
+    message: string;
+}>;
+export declare function getCustomAttribute(username: string, userPoolId: string, attributeName: string): Promise<{
+    success: boolean;
+    value?: string;
+    message: string;
+}>;