docta-package 1.0.1 → 1.1.0

package/build/models/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./base"), exports);
+__exportStar(require("./doctor"), exports);
+__exportStar(require("./education"), exports);
+__exportStar(require("./faq"), exports);
+__exportStar(require("./language"), exports);
+__exportStar(require("./location"), exports);
+__exportStar(require("./patient"), exports);
+__exportStar(require("./position"), exports);
+__exportStar(require("./specialty"), exports);
+__exportStar(require("./user"), exports);

package/build/models/language.d.ts

@@ -0,0 +1,15 @@
+import { Schema } from "mongoose";
+import { EnumLanguageLevel } from "../enums";
+export interface ILanguage {
+    title: string;
+    level: EnumLanguageLevel;
+}
+export declare const LanguageSchema: Schema<ILanguage, import("mongoose").Model<ILanguage, any, any, any, import("mongoose").Document<unknown, any, ILanguage, any, {}> & ILanguage & {
+    _id: import("mongoose").Types.ObjectId;
+} & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, ILanguage, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<ILanguage>, {}, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & import("mongoose").FlatRecord<ILanguage> & {
+    _id: import("mongoose").Types.ObjectId;
+} & {
+    __v: number;
+}>;

package/build/models/language.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LanguageSchema = void 0;
+const mongoose_1 = require("mongoose");
+const enums_1 = require("../enums");
+exports.LanguageSchema = new mongoose_1.Schema({
+    title: { type: String, required: true, trim: true },
+    level: {
+        type: String,
+        enum: Object.values(enums_1.EnumLanguageLevel),
+        required: true,
+        trim: true,
+    },
+}, { _id: false });

package/build/models/location.d.ts

@@ -0,0 +1,19 @@
+import { Schema } from "mongoose";
+export interface ILocation {
+    address?: string;
+    city?: string;
+    country?: string;
+    lat?: number;
+    lng?: number;
+    zipcode?: string;
+    distanceInMeters?: number | null;
+}
+export declare const LocationSchema: Schema<ILocation, import("mongoose").Model<ILocation, any, any, any, import("mongoose").Document<unknown, any, ILocation, any, {}> & ILocation & {
+    _id: import("mongoose").Types.ObjectId;
+} & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, ILocation, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<ILocation>, {}, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & import("mongoose").FlatRecord<ILocation> & {
+    _id: import("mongoose").Types.ObjectId;
+} & {
+    __v: number;
+}>;

package/{src/models/location.ts → build/models/location.js}

@@ -1,17 +1,8 @@
-import { Schema } from "mongoose";
-
-export interface ILocation {
-  address?: string;
-  city?: string;
-  country?: string; // ISO code eg: fr
-  lat?: number;
-  lng?: number;
-  zipcode?: string;
-  distanceInMeters?: number | null;
-}
-
-export const LocationSchema = new Schema<ILocation>(
-  {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocationSchema = void 0;
+const mongoose_1 = require("mongoose");
+exports.LocationSchema = new mongoose_1.Schema({
     address: { type: String, required: false, trim: true },
     city: { type: String, required: false, trim: true },
     country: { type: String, required: false, trim: true },
@@ -19,6 +10,4 @@ export const LocationSchema = new Schema<ILocation>(
     lng: { type: Number, required: false },
     zipcode: { type: String, required: false, trim: true },
     distanceInMeters: { type: Number, required: false, default: null },
-  },
-  { _id: false }
-);
+}, { _id: false });

package/build/models/patient.d.ts

@@ -0,0 +1,15 @@
+import { Document, Model } from "mongoose";
+import { IUserDocument } from ".";
+import { IBaseModel } from ".";
+import { Gender } from "../enums";
+export interface IPatient extends IBaseModel {
+    user: IUserDocument;
+    dob?: number;
+    gender?: Gender;
+    phoneNumber?: string;
+}
+export interface IPatientDocument extends IPatient, Document {
+}
+export interface IPatientModel extends Model<IPatientDocument> {
+}
+export declare const PatientModel: IPatientModel;

package/build/models/patient.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PatientModel = void 0;
+const mongoose_1 = require("mongoose");
+const _1 = require(".");
+const _2 = require(".");
+const enums_1 = require("../enums");
+const PatientSchema = new mongoose_1.Schema(Object.assign(Object.assign({}, _2.BaseSchemaFields), { user: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: _1.UserModel.modelName,
+        required: true,
+        onDelete: "cascade",
+    }, dob: { type: Number, required: false }, phoneNumber: { type: String, required: false }, gender: { type: String, enum: Object.values(enums_1.Gender), required: false } }));
+PatientSchema.plugin(_2.BaseSchemaPlugin);
+exports.PatientModel = (0, mongoose_1.model)("Patient", PatientSchema);

package/build/models/position.d.ts

@@ -0,0 +1,16 @@
+import { Schema } from "mongoose";
+export interface IPosition {
+    startDate: number;
+    endDate?: number;
+    title: string;
+    company: string;
+}
+export declare const PositionSchema: Schema<IPosition, import("mongoose").Model<IPosition, any, any, any, import("mongoose").Document<unknown, any, IPosition, any, {}> & IPosition & {
+    _id: import("mongoose").Types.ObjectId;
+} & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, IPosition, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<IPosition>, {}, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & import("mongoose").FlatRecord<IPosition> & {
+    _id: import("mongoose").Types.ObjectId;
+} & {
+    __v: number;
+}>;

package/build/models/position.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PositionSchema = void 0;
+const mongoose_1 = require("mongoose");
+exports.PositionSchema = new mongoose_1.Schema({
+    startDate: { type: Number, required: true },
+    endDate: { type: Number, required: false },
+    title: { type: String, required: true, trim: true },
+    company: { type: String, required: true, trim: true },
+}, { _id: false });

package/build/models/specialty.d.ts

@@ -0,0 +1,15 @@
+import { Document, Model } from "mongoose";
+import { IBaseModel } from ".";
+export interface ILocalizedSpecialtyFields {
+    name: string;
+    description?: string | null;
+}
+export interface ISpecialty extends IBaseModel {
+    en: ILocalizedSpecialtyFields;
+    fr?: ILocalizedSpecialtyFields;
+}
+export interface ISpecialtyDocument extends ISpecialty, Document {
+}
+export interface ISpecialtyModel extends Model<ISpecialtyDocument> {
+}
+export declare const SpecialtyModel: ISpecialtyModel;

package/build/models/specialty.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpecialtyModel = void 0;
+const mongoose_1 = require("mongoose");
+const _1 = require(".");
+const LocalizedFieldsSchema = new mongoose_1.Schema({
+    name: { type: String, required: true },
+    description: { type: String, default: null },
+}, { _id: false });
+const SpecialtySchema = new mongoose_1.Schema(Object.assign(Object.assign({}, _1.BaseSchemaFields), { en: { type: LocalizedFieldsSchema, required: true }, fr: { type: LocalizedFieldsSchema, required: false, default: null } }));
+SpecialtySchema.plugin(_1.BaseSchemaPlugin);
+exports.SpecialtyModel = (0, mongoose_1.model)("Specialty", SpecialtySchema);

package/build/models/user.d.ts

@@ -0,0 +1,19 @@
+import { Document, Model } from "mongoose";
+import { EnumUserRole } from "../enums";
+import { IBaseModel } from ".";
+export interface IUser extends IBaseModel {
+    role: EnumUserRole;
+    name: string;
+    email: string;
+    password?: string;
+    activationToken?: string | null;
+    forgotPasswordToken?: string | null;
+    token?: string | null;
+    isActive: boolean;
+}
+export interface IUserDocument extends IUser, Document {
+    comparePassword(candidatePassword: string): Promise<boolean>;
+}
+export interface IUserModel extends Model<IUserDocument> {
+}
+export declare const UserModel: IUserModel;

package/build/models/user.js

@@ -0,0 +1,47 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserModel = void 0;
+const mongoose_1 = require("mongoose");
+const enums_1 = require("../enums");
+const bcrypt = require("bcryptjs");
+const _1 = require(".");
+const UserSchema = new mongoose_1.Schema(Object.assign(Object.assign({}, _1.BaseSchemaFields), { name: { type: String, required: true }, email: { type: String, required: true, unique: true, trim: true }, password: { type: String, required: false, default: null }, activationToken: { type: String, default: null }, forgotPasswordToken: { type: String, default: null }, token: { type: String, default: null }, isActive: { type: Boolean, default: false }, role: {
+        type: String,
+        enum: Object.values(enums_1.EnumUserRole),
+        default: enums_1.EnumUserRole.PATIENT,
+    } }));
+UserSchema.plugin(_1.BaseSchemaPlugin);
+UserSchema.pre("save", function (next) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!this.isModified("password")) {
+            return next();
+        }
+        try {
+            const salt = yield bcrypt.genSalt(10);
+            this.password = yield bcrypt.hash(this.password, salt);
+            return next();
+        }
+        catch (error) {
+            return next(error);
+        }
+    });
+});
+UserSchema.methods.comparePassword = function (candidatePassword) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return bcrypt.compare(candidatePassword, this.password);
+    });
+};
+exports.UserModel = (0, mongoose_1.model)("User", UserSchema);
+// const tot = async (): Promise<IUserDocument[]> => {
+//   const user: IUserDocument[] = await UserModel.find({});
+//   return user;
+// };

package/build/utils/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./orchestration-result"), exports);
+__exportStar(require("./s3-helper"), exports);
+__exportStar(require("./token-utils"), exports);
+__exportStar(require("./validate-info"), exports);
+__exportStar(require("./winston"), exports);

package/build/utils/orchestration-result.d.ts

@@ -0,0 +1,38 @@
+import { EnumStatusCode } from "../enums";
+export type ErrorResult = {
+    code: EnumStatusCode;
+    message: string;
+};
+export type PaginatedResult<T> = {
+    code: EnumStatusCode;
+    message: string;
+    data: {
+        items: T[];
+        totalItems: number;
+        itemsPerPage: number;
+        page: number;
+        totalPages: number;
+    };
+};
+export type SimpleItemResult<T> = {
+    code: EnumStatusCode;
+    message: string;
+    data: {
+        item: T;
+    } | undefined;
+};
+export declare class OrchestrationResult {
+    static paginated<T>({ data, totalItems, itemsPerPage, page, code, message, }: {
+        data: T[];
+        totalItems: number;
+        itemsPerPage: number;
+        page: number;
+        code: EnumStatusCode;
+        message: string;
+    }): PaginatedResult<T>;
+    static item<T>({ code, data, message, }: {
+        code: EnumStatusCode;
+        message: string;
+        data?: T;
+    }): SimpleItemResult<T>;
+}

package/build/utils/orchestration-result.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrchestrationResult = void 0;
+class OrchestrationResult {
+    static paginated({ data, totalItems, itemsPerPage, page, code, message, }) {
+        return {
+            code,
+            message,
+            data: {
+                items: data,
+                totalItems,
+                itemsPerPage,
+                page,
+                totalPages: Math.ceil(totalItems / itemsPerPage),
+            },
+        };
+    }
+    static item({ code, data, message, }) {
+        return {
+            code,
+            message,
+            data: data === undefined ? undefined : { item: data },
+        };
+    }
+}
+exports.OrchestrationResult = OrchestrationResult;

package/build/utils/s3-helper.d.ts

@@ -0,0 +1,13 @@
+export declare class AwsS3Helper {
+    private s3;
+    private bucketName;
+    private bucketRegion;
+    private accessKey;
+    private secretKey;
+    private signedUrlExpiry;
+    constructor();
+    private sendCommand;
+    uploadImage(key: string, contentType: string, file: Buffer): Promise<string>;
+    getImageUrl(key: string): Promise<string>;
+    deleteImageFromS3(key: string): Promise<void>;
+}

package/build/utils/s3-helper.js

@@ -0,0 +1,67 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AwsS3Helper = void 0;
+const client_s3_1 = require("@aws-sdk/client-s3");
+const s3_request_presigner_1 = require("@aws-sdk/s3-request-presigner");
+const config_1 = require("../config");
+class AwsS3Helper {
+    constructor() {
+        this.signedUrlExpiry = 3600; // 1 hour
+        this.bucketName = config_1.generalConfig.awsS3Bucket;
+        this.bucketRegion = config_1.generalConfig.awsS3Region;
+        this.accessKey = config_1.generalConfig.awsAccessKey;
+        this.secretKey = config_1.generalConfig.awsSecretKey;
+        this.s3 = new client_s3_1.S3Client({
+            credentials: {
+                accessKeyId: this.accessKey,
+                secretAccessKey: this.secretKey,
+            },
+            region: this.bucketRegion,
+            requestHandler: { socketTimeout: 120000 },
+        });
+    }
+    sendCommand(command) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.s3.send(command);
+        });
+    }
+    uploadImage(key, contentType, file) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const s3Key = key;
+            yield this.sendCommand(new client_s3_1.PutObjectCommand({
+                Bucket: this.bucketName,
+                Key: s3Key,
+                Body: file,
+                ContentType: contentType,
+            }));
+            return s3Key;
+        });
+    }
+    getImageUrl(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const command = new client_s3_1.GetObjectCommand({
+                Bucket: this.bucketName,
+                Key: key,
+            });
+            return (0, s3_request_presigner_1.getSignedUrl)(this.s3, command, { expiresIn: this.signedUrlExpiry });
+        });
+    }
+    deleteImageFromS3(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.sendCommand(new client_s3_1.DeleteObjectCommand({
+                Bucket: this.bucketName,
+                Key: key,
+            }));
+        });
+    }
+}
+exports.AwsS3Helper = AwsS3Helper;

package/build/utils/token-utils.d.ts

@@ -0,0 +1,11 @@
+import { LoggedInUserTokenData } from "../interfaces";
+export declare class TokenUtils {
+    static createActivationToken(userId: string): string;
+    static decodeActivationToken(token: string): string | null;
+    static createAccessToken(payload: LoggedInUserTokenData): string;
+    static createRefreshToken(payload: LoggedInUserTokenData): string;
+    static verifyRefreshToken(token: string): LoggedInUserTokenData | null;
+    static verifyAccessToken(token: string): LoggedInUserTokenData;
+    static createForgotPasswordToken(userId: string): string;
+    static decodeForgotPasswordToken(token: string): string | null;
+}

package/build/utils/token-utils.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenUtils = void 0;
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const config_1 = require("../config");
+class TokenUtils {
+    static createActivationToken(userId) {
+        return jsonwebtoken_1.default.sign({ userId }, config_1.generalConfig.accessTokenSecret);
+    }
+    static decodeActivationToken(token) {
+        try {
+            const decoded = jsonwebtoken_1.default.verify(token, config_1.generalConfig.activationTokenSecret);
+            if (typeof decoded === "string") {
+                return null;
+            }
+            return typeof decoded.userId === "string" ? decoded.userId : null;
+        }
+        catch (_a) {
+            return null;
+        }
+    }
+    static createAccessToken(payload) {
+        return jsonwebtoken_1.default.sign(payload, config_1.generalConfig.accessTokenSecret, {
+            expiresIn: config_1.generalConfig.accessTokenExpiry,
+        });
+    }
+    static createRefreshToken(payload) {
+        return jsonwebtoken_1.default.sign(payload, config_1.generalConfig.refreshTokenSecret, {
+            expiresIn: config_1.generalConfig.refreshTokenExpiry,
+        });
+    }
+    static verifyRefreshToken(token) {
+        try {
+            const decoded = jsonwebtoken_1.default.verify(token, config_1.generalConfig.refreshTokenSecret);
+            return {
+                id: decoded.id,
+                email: decoded.email,
+                role: decoded.role,
+            };
+        }
+        catch (_a) {
+            return null;
+        }
+    }
+    static verifyAccessToken(token) {
+        try {
+            const decoded = jsonwebtoken_1.default.verify(token, config_1.generalConfig.accessTokenSecret);
+            return {
+                id: decoded.id,
+                email: decoded.email,
+                role: decoded.role,
+            };
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    static createForgotPasswordToken(userId) {
+        return jsonwebtoken_1.default.sign({ userId }, config_1.generalConfig.forgotPasswordTokenSecret);
+    }
+    static decodeForgotPasswordToken(token) {
+        try {
+            const decoded = jsonwebtoken_1.default.verify(token, config_1.generalConfig.forgotPasswordTokenSecret);
+            if (typeof decoded === "string") {
+                return null;
+            }
+            return typeof decoded.userId === "string" ? decoded.userId : null;
+        }
+        catch (_a) {
+            return null;
+        }
+    }
+}
+exports.TokenUtils = TokenUtils;

package/build/utils/validate-info.d.ts

@@ -0,0 +1,4 @@
+import { IUserDocument } from "../models";
+export declare class ValidateInfo {
+    static validateUser(user: IUserDocument): void;
+}

package/build/utils/validate-info.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidateInfo = void 0;
+const enums_1 = require("../enums");
+const errors_1 = require("../errors");
+const errors_2 = require("../errors");
+class ValidateInfo {
+    static validateUser(user) {
+        if (!user) {
+            throw new errors_1.NotFoundError(enums_1.EnumStatusCode.NOT_FOUND, "User not found");
+        }
+        if (user.isDeleted) {
+            throw new errors_2.UnAuthorizedError(enums_1.EnumStatusCode.ACCOUNT_DELETED, "Your account has been deleted");
+        }
+        if (!user.isActive) {
+            throw new errors_2.UnAuthorizedError(enums_1.EnumStatusCode.ACCOUNT_DEACTIVATED, "Account is deactivated");
+        }
+    }
+}
+exports.ValidateInfo = ValidateInfo;

package/build/utils/winston.d.ts

@@ -0,0 +1,3 @@
+import winston from "winston";
+import "winston-daily-rotate-file";
+export declare const logger: winston.Logger;

package/build/utils/winston.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+// src/utils/logger.ts
+const winston_1 = __importDefault(require("winston"));
+require("winston-daily-rotate-file");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const logDir = path_1.default.join(process.cwd(), "logs");
+// ensure logs directory exists
+if (!fs_1.default.existsSync(logDir)) {
+    fs_1.default.mkdirSync(logDir, { recursive: true });
+}
+const transport = new winston_1.default.transports.DailyRotateFile({
+    dirname: logDir,
+    filename: "%DATE%.log",
+    datePattern: "YYYY-MM-DD",
+    zippedArchive: false,
+    maxSize: "20m",
+    maxFiles: "14d",
+});
+exports.logger = winston_1.default.createLogger({
+    level: "error",
+    format: winston_1.default.format.combine(winston_1.default.format.timestamp(), winston_1.default.format.json()),
+    transports: [
+        transport,
+        new winston_1.default.transports.Console({ format: winston_1.default.format.simple() }), // optional
+    ],
+});

package/package.json

@@ -1,14 +1,19 @@
 {
   "name": "docta-package",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "This package will contail all the required files to run the docta micro-service app",
   "main": "index.js",
   "types": "build/index.d.ts",
+  "files": [
+    "build"
+  ],
   "scripts": {
     "clean": "rm -rf build",
     "build": "npm run clean && tsc",
     "prepublishOnly": "npm run build",
-    "release": "npm version patch -m 'Release %s' && npm publish --access public"
+    "release:patch": "npm version patch -m 'Release %s' && npm run build && npm publish --access public",
+    "release:minor": "npm version minor -m 'Release %s' && npm run build && npm publish --access public",
+    "release:major": "npm version major -m 'Release %s' && npm run build && npm publish --access public"
   },
   "author": "",
   "license": "ISC",

package/src/config.ts

@@ -1,25 +0,0 @@
-interface GeneralConfig {
-  accessTokenSecret: string;
-  refreshTokenSecret: string;
-  accessTokenExpiry: number;
-  refreshTokenExpiry: number;
-  awsAccessKey: string;
-  awsSecretKey: string;
-  awsS3Bucket: string;
-  awsS3Region: string;
-  forgotPasswordTokenSecret: string;
-  activationTokenSecret: string;
-}
-
-export const generalConfig: GeneralConfig = {
-  accessTokenSecret: String(process.env.ACCESS_TOKEN_SECRET),
-  refreshTokenSecret: String(process.env.REFRESH_TOKEN_SECRET),
-  accessTokenExpiry: Number(process.env.ACCESS_TOKEN_EXPIRY),
-  refreshTokenExpiry: Number(process.env.REFRESH_TOKEN_EXPIRY),
-  awsAccessKey: String(process.env.AWS_ACCESS_KEY),
-  awsSecretKey: String(process.env.AWS_SECRET_KEY),
-  awsS3Bucket: String(process.env.AWS_S3_BUCKET),
-  awsS3Region: String(process.env.AWS_S3_REGION),
-  forgotPasswordTokenSecret: String(process.env.FORGOT_PASSWORD_TOKEN_SECRET),
-  activationTokenSecret: String(process.env.ACTIVATION_TOKEN_SECRET),
-};