@kipicore/dbcore 1.0.3

package/dist/db/mongodb.d.ts

@@ -0,0 +1 @@
+export declare const connectMongo: () => Promise<void>;

package/dist/db/mongodb.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectMongo = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const { MONGO_URI } = process.env;
+if (!MONGO_URI) {
+    throw new Error("MongoDB environment variable MONGO_URI is missing");
+}
+const connectMongo = async () => {
+    try {
+        await mongoose_1.default.connect(MONGO_URI, {
+            autoIndex: process.env.NODE_ENV !== "production",
+        });
+        console.log("MongoDB connected");
+    }
+    catch (err) {
+        console.error("MongoDB connection error:", err);
+        throw err;
+    }
+};
+exports.connectMongo = connectMongo;

package/dist/db/postgres.d.ts

@@ -0,0 +1,2 @@
+import { Sequelize } from "sequelize";
+export declare const sequelize: Sequelize;

package/dist/db/postgres.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sequelize = void 0;
+const sequelize_1 = require("sequelize");
+const { POSTGRES_HOST, POSTGRES_PORT, POSTGRES_DB, POSTGRES_USER, POSTGRES_PASSWORD, POSTGRES_SSL, } = process.env;
+if (!POSTGRES_HOST || !POSTGRES_DB || !POSTGRES_USER || !POSTGRES_PASSWORD) {
+    throw new Error("Postgres environment variables are missing");
+}
+exports.sequelize = new sequelize_1.Sequelize(POSTGRES_DB, POSTGRES_USER, POSTGRES_PASSWORD, {
+    host: POSTGRES_HOST,
+    port: POSTGRES_PORT ? parseInt(POSTGRES_PORT, 10) : 5432,
+    dialect: "postgres",
+    dialectOptions: {
+        ssl: POSTGRES_SSL === "true" ? { require: true, rejectUnauthorized: false } : false,
+    },
+    logging: process.env.NODE_ENV === "development" ? console.log : false,
+});

package/dist/helpers/s3Uploader.d.ts

@@ -0,0 +1,3 @@
+import { IFileStorageAttributes } from '../interfaces/fileStorageInterface';
+export declare const uploadFileToS3: (localFilePath: string, s3Key: string, s3Bucket?: string) => Promise<string>;
+export declare const getPresignedUrl: (bucket: string, fileStorage: IFileStorageAttributes, expiresIn?: number) => Promise<string>;

package/dist/helpers/s3Uploader.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPresignedUrl = exports.uploadFileToS3 = void 0;
+// src/utils/s3Uploader.ts
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const aws_1 = require("../configs/aws");
+const env_1 = require("../configs/env");
+const client_s3_1 = require("@aws-sdk/client-s3");
+const s3_request_presigner_1 = require("@aws-sdk/s3-request-presigner");
+const uploadFileToS3 = async (localFilePath, s3Key, s3Bucket = env_1.ENV_VARIABLE.AWS_BUCKET_NAME) => {
+    try {
+        const fileContent = fs_1.default.readFileSync(localFilePath);
+        const contentType = getMimeTypeFromExt(path_1.default.extname(localFilePath));
+        const command = new client_s3_1.PutObjectCommand({
+            Bucket: s3Bucket,
+            Key: s3Key,
+            Body: fileContent,
+            ContentType: contentType,
+            // ACL: 'public-read', // ✅ For public access
+        });
+        await aws_1.s3.send(command);
+        // Delete local file after successful upload
+        fs_1.default.unlinkSync(localFilePath);
+        const filePath = `https://${s3Bucket}.s3.${env_1.ENV_VARIABLE.AWS_REGION}.amazonaws.com/${s3Key}`;
+        return filePath;
+    }
+    catch (err) {
+        fs_1.default.unlinkSync(localFilePath);
+        throw err;
+    }
+};
+exports.uploadFileToS3 = uploadFileToS3;
+const getPresignedUrl = async (bucket, fileStorage, expiresIn = 60 * 60 * 24) => {
+    const s3Key = `${fileStorage.storagePath}/${fileStorage.storageFileName}`;
+    const command = new client_s3_1.GetObjectCommand({
+        Bucket: bucket,
+        Key: s3Key,
+    });
+    const signedUrl = await (0, s3_request_presigner_1.getSignedUrl)(aws_1.s3, command, { expiresIn }); // in seconds
+    return signedUrl;
+};
+exports.getPresignedUrl = getPresignedUrl;
+const getMimeTypeFromExt = (ext) => {
+    switch (ext.toLowerCase()) {
+        case '.jpg':
+        case '.jpeg':
+            return 'image/jpeg';
+        case '.png':
+            return 'image/png';
+        case '.gif':
+            return 'image/gif';
+        case '.pdf':
+            return 'application/pdf';
+        default:
+            return 'application/octet-stream';
+    }
+};

package/dist/helpers/utils.d.ts

@@ -0,0 +1,173 @@
+import Joi from 'joi';
+import { OrderItem } from 'sequelize';
+export declare const pick: <T extends object, K extends keyof T>(objOrArray: T | T[], keys: K[]) => Pick<T, K> | Pick<T, K>[];
+export declare const isValidMongoDbId: Joi.StringSchema<string>;
+export declare const omit: <T extends object, K extends keyof T>(objOrArray: T | T[], keys: K[]) => Omit<T, K> | Omit<T, K>[];
+export declare const ensureDirectoryExists: (directory: string) => void;
+export declare const generateOtp: (length?: number) => string;
+export declare const generateAlphaNumericCode: (length?: number) => string;
+export declare const generateTempPassword: (length?: number) => string;
+type UniqueByFields<T> = (array: T[], fields: (keyof T)[]) => T[];
+export declare const getUniqueArrayByFields: UniqueByFields<any>;
+export declare const keyByFieldOrFields: <T>(array: T[], fields: keyof T | (keyof T)[]) => Record<string, T>;
+/**
+ * Groups an array of objects by a specified field or multiple fields.
+ *
+ * @param array - The array of objects to group.
+ * @param fields - A single field or an array of fields to group by.
+ * @returns An object where keys are the grouped field values and values are arrays of grouped objects.
+ */
+export declare function groupByFieldOrFields<T>(array: T[], fields: keyof T | (keyof T)[]): Record<string, T[]>;
+export declare const isTimeWithinRange: (time: Date, rangeStart: Date, rangeEnd: Date) => boolean;
+export declare const isDateWithinRange: (date: Date | string, rangeStart: Date | string, rangeEnd: Date | string) => boolean;
+export declare const startOfDay: (date: string | Date) => Date;
+export declare const generateUuidToNumber: (uuid?: string) => string;
+export declare const endOfDay: (date: string | Date) => Date;
+type GroupByFields<T> = (array: T[], fields: keyof T | (keyof T)[]) => Record<string, T[]>;
+export declare const groupByFields: GroupByFields<any>;
+type SortOrder = 'asc' | 'desc';
+interface SortField<T> {
+    key: keyof T;
+    order?: SortOrder;
+}
+/**
+ * Sorts an array of objects based on specified fields and order.
+ *
+ * @param array - The array to be sorted.
+ * @param fields - A single sort field or an array of sort fields.
+ * @returns A new sorted array.
+ */
+export declare const sortArray: <T>(array: T[], fields: SortField<T> | SortField<T>[]) => T[];
+/**
+ * Gets all nested children for a given parent ID.
+ *
+ * @param array - Array of nodes representing the flat hierarchy.
+ * @param parentIds - The ID of the parent node.
+ * @param parentIdKey - The key used to reference the parent ID.
+ * @returns A flattened list of all children.
+ */
+export declare const getChildrenByParentId: <T extends Record<string, any>>(array: T[], parentIds: string | string[], parentIdKey: keyof T) => T[];
+/**
+ * Gets all nested children for a given parent ID.
+ *
+ * @param array - Array of nodes representing the flat hierarchy.
+ * @param childIds - The ID of the parent node.
+ * @param parentIdKey - The key used to reference the parent ID..
+ * @returns A flattened list of all parents.
+ */
+export declare const getParentsByChildrenId: <T extends Record<string, any>>(array: T[], childIds: string | string[], parentIdKey: keyof T) => T[];
+/**
+ * Builds a nested structure from a flat array of items based on a parent-child relationship.
+ *
+ * @param items - The array of items that need to be organized.
+ * @param parentIdKey - The key that refers to the parent ID in each item.
+ * @param nestedListKey - The key that will store the nested child items for each parent.
+ *
+ * @returns An array of root-level items, each containing its nested children in the `nestedListKey`.
+ */
+export declare const buildNestedStructure: <T extends Record<string, any>>(items: T[], parentIdKey: keyof T, nestedListKey: string) => T[];
+/**
+ * Flattens a nested structure into a flat array while preserving the parent-child relationship.
+ *
+ * @param items - The nested array of items to be flattened.
+ * @param parentIdKey - The key that will store the parent ID in each flattened item.
+ * @param nestedListKey - The key that contains the nested child items.
+ *
+ * @returns A flat array of items, each containing a reference to its parent ID.
+ */
+export declare const flattenNestedStructure: <T extends Record<string, any>>(items: T[], parentIdKey: keyof T, nestedListKey: string) => Omit<T, typeof nestedListKey>[];
+/**
+ * Removes all falsy values from an object.
+ *
+ * A falsy value in JavaScript/TypeScript includes:
+ * - false
+ * - 0 (zero)
+ * - "" (empty string)
+ * - null
+ * - undefined
+ * - NaN (Not-a-Number)
+ *
+ * This function iterates through the object's properties and removes any key-value pairs
+ * where the value is falsy. Only truthy values remain in the final object.
+ *
+ * @param obj - The input object containing key-value pairs.
+ * @returns A new object with all falsy values removed.
+ *
+ * @example
+ * const data = {
+ *   name: "Alice",
+ *   age: 25,
+ *   isAdmin: false,
+ *   score: 0,
+ *   city: "",
+ *   country: "USA",
+ *   email: null,
+ *   phone: undefined,
+ *   balance: NaN,
+ * };
+ *
+ * const cleanedData = removeFalsyValues(data);
+ * console.log(cleanedData);
+ * // Output: { name: 'Alice', age: 25, country: 'USA' }
+ */
+export declare const removeFalsyValues: <T extends Record<string, any>>(obj: T) => Partial<T>;
+export declare const isValidUUID: (id: string, expectedVersion?: 1 | 4) => boolean;
+/**
+ * Parses ordering input and returns Sequelize-compatible order array.
+ *
+ * @param inputOrder - Array like [["columnName", "ASC"], ...]
+ * @param defaultOrder - Fallback or additional default order (e.g. [['createdAt', 'DESC']])
+ */
+export declare const parseOrderOptions: (inputOrder: unknown, defaultOrder?: OrderItem[]) => OrderItem[];
+import { IInstituteAttributes } from '../interfaces/instituteInterface';
+import { IUserAttributes } from '../interfaces/userInterface';
+import { TAeraModelCreationAttributes } from '../types/areaType';
+export declare const capitalizeFirst: (str: string) => string;
+export declare const normalizeToArray: (value: string | string[] | undefined) => string[] | undefined;
+/**
+ * Converts a snake_case string to Normal Text
+ * @param {string} input - The snake_case string
+ * @returns {string} - The converted Normal Text
+ */
+export declare const fromSnakeCaseToNormalText: (input: string) => string;
+export declare function slugify(text: string): string;
+export declare function assignNonNull<T extends Record<string, any>>(target: T, source: Record<string, any>): void;
+export declare function isUserSchoolInfoUpdate(institute: IInstituteAttributes, reqUser: IUserAttributes & {
+    isAddDetails?: boolean;
+}): boolean;
+export declare function chunkArray<T>(array: T[], size: number): T[][];
+/**
+ * Prepares userdata for EJS template based on dynamic columns config.
+ * @param data Array of objects
+ * @param columnsConfig Array of columns with { title, field }
+ * @returns { userdata: any[], columns: string[] }
+ */
+export declare function extractFromObject(data: any[], config: {
+    tableTitle: string;
+    columns: {
+        title: string;
+        field: string;
+    }[];
+}): {
+    tableTitle: string;
+    userdata: any[];
+    columns: string[];
+};
+export declare const enumAlternatives: (enumObj: Record<string, string>, isRequired?: boolean, allowArray?: boolean) => Joi.StringSchema<string> | Joi.AlternativesSchema<any>;
+export declare const objectIdAlternatives: (isRequired?: boolean, allowArray?: boolean) => Joi.AlternativesSchema<any> | undefined;
+export declare const uuidIdAlternatives: (isRequired?: boolean, allowArray?: boolean) => Joi.AlternativesSchema<any> | undefined;
+export declare const customPagination: (data: any[], page: number, limit: number, totalRecords: number) => Promise<{
+    limit: number;
+    totalRecords: number;
+    totalPages: number;
+    hasPreviousPage: boolean;
+    currentPage: number;
+    hasNextPage: boolean;
+    recordList: any[];
+}>;
+export declare const generateHmacSHA256: (data: string, secret: string) => string;
+export declare const verifyHmacSHA256: (data: string, secret: string, signature: string) => boolean;
+export declare const generateVoucherCode: (format?: string) => string;
+export declare const getCityAreas: (cityName?: string) => Promise<Partial<TAeraModelCreationAttributes>[]>;
+export declare const getNextLetter: (current: string) => string;
+export {};