@hemia/db-connector 0.0.1

package/dist/types/abstract/NoSQLConnector.d.ts

@@ -0,0 +1,40 @@
+import { AggregateOptions, ClientSession, Connection, Document, Model, PipelineStage } from "mongoose";
+import { CredentialsConnection } from "../types/CredentialsConnection";
+import { NoSQLOptions } from "../types/NoSQLOptions";
+export declare abstract class NoSQLConnector {
+    protected config: CredentialsConnection;
+    protected provider: string;
+    protected connection: any;
+    constructor();
+    abstract connect(): Promise<void>;
+    abstract disconnect(): Promise<void>;
+    abstract getConnection(): Connection;
+    abstract isConnected(): boolean;
+    abstract state(): number;
+    abstract getCredentials(): CredentialsConnection;
+    abstract getProvider(): String;
+    abstract startSession(): Promise<ClientSession>;
+    abstract commitTransaction(): Promise<void>;
+    abstract abortTransaction(): Promise<void>;
+    abstract withTransaction<T>(transactionFn: (session: ClientSession) => Promise<T>): Promise<T>;
+    abstract create<T>(model: any, data: Partial<T>): Promise<T>;
+    abstract create<T extends Document>(model: Model<T>, data: Partial<T>, session?: ClientSession): Promise<T>;
+    abstract find<T>(model: any, query: object, options?: NoSQLOptions): Promise<T[]>;
+    abstract find<T extends Document>(model: Model<T>, query: object, options?: NoSQLOptions): Promise<T[]>;
+    abstract findOne<T>(model: any, query: object): Promise<T | null>;
+    abstract findOne<T extends Document>(model: Model<T>, query: object): Promise<T | null>;
+    abstract findById<T>(model: any, id: string): Promise<T | null>;
+    abstract findById<T extends Document>(model: Model<T>, id: string): Promise<T | null>;
+    abstract update<T>(model: any, query: object, updateData: object): Promise<T | null>;
+    abstract update<T extends Document>(model: Model<T>, query: object, updateData: object, session?: ClientSession): Promise<T | null>;
+    abstract updateById<T>(model: any, id: string, updateData: object): Promise<T | null>;
+    abstract updateById<T extends Document>(model: Model<T>, id: string, updateData: object, session?: ClientSession): Promise<T | null>;
+    abstract delete<T>(model: any, query: object): Promise<boolean>;
+    abstract delete<T extends Document>(model: Model<T>, query: object, session?: ClientSession): Promise<boolean>;
+    abstract deleteById<T>(model: any, id: string): Promise<boolean>;
+    abstract deleteById<T extends Document>(model: Model<T>, id: string, session?: ClientSession): Promise<boolean>;
+    abstract findAllFromMultipleModels<U>(models: any[], filter: object): Promise<U[]>;
+    abstract findAllFromMultipleModels<U extends Document>(models: Array<Model<U>>, filter: object): Promise<U[]>;
+    abstract aggregate<T>(model: any, pipeline: PipelineStage[]): Promise<any[]>;
+    abstract aggregate<T extends Document>(model: Model<T>, pipeline: PipelineStage[], options?: AggregateOptions): Promise<any[]>;
+}

package/dist/types/abstract/SQLConnector.d.ts

@@ -0,0 +1,22 @@
+import { CreateOptions, CreationAttributes, DestroyOptions, FindOptions, InferAttributes, Model, QueryOptions, Sequelize, Transaction, UpdateOptions, WhereOptions } from "sequelize";
+export type Filter = Record<string, any>;
+export declare abstract class SqlConnector {
+    abstract connect(): Promise<void>;
+    abstract disconnect(): Promise<void>;
+    abstract getSequelize(): Sequelize;
+    abstract isConnected(): Promise<boolean>;
+    abstract select<T extends Model<InferAttributes<T>>, O extends FindOptions<InferAttributes<T>> = FindOptions<InferAttributes<T>>>(entity: string, options?: O & {
+        where?: WhereOptions<InferAttributes<T>>;
+    }): Promise<T[]>;
+    abstract insert<T extends Model<InferAttributes<T>>, O extends CreateOptions<InferAttributes<T>> = CreateOptions<InferAttributes<T>>>(entity: string, values: CreationAttributes<T>, options?: O): Promise<O extends {
+        returning: false;
+    } | {
+        ignoreDuplicates: true;
+    } ? void : T>;
+    abstract update<T extends Model<InferAttributes<T>>, O extends UpdateOptions<InferAttributes<T>> = UpdateOptions<InferAttributes<T>>>(entity: string, filter: WhereOptions<InferAttributes<T>>, data: Partial<InferAttributes<T>>, options?: O & {
+        where?: WhereOptions<InferAttributes<T>>;
+    }): Promise<number>;
+    abstract delete<T extends Model<InferAttributes<T>>, O extends DestroyOptions<InferAttributes<T>> = DestroyOptions<InferAttributes<T>>>(entity: string, filter: WhereOptions<InferAttributes<T>>, options?: O): Promise<number>;
+    abstract query<T>(sql: string, options?: QueryOptions): Promise<T[]>;
+    abstract withTransaction<T>(fn: (tx: Transaction) => Promise<T>): Promise<T>;
+}

package/dist/types/enums/CoreSqlTypes.d.ts

@@ -0,0 +1,8 @@
+export declare enum CoreSqlTypes {
+    Number = "Number",
+    string = "string",
+    DateTime = "DateTime",
+    Decimal = "Decimal",
+    Boolean = "Boolean",
+    Float = "Float"
+}

package/dist/types/enums/QueryType.d.ts

@@ -0,0 +1,4 @@
+export declare enum QueryType {
+    STORE = "STORE",
+    QUERY = "QUERY"
+}

package/dist/types/errors/DBError.d.ts

@@ -0,0 +1,11 @@
+export declare class DBError extends Error {
+    readonly code: string;
+    readonly sqlState?: string;
+    readonly errno?: number;
+    readonly status?: number;
+    constructor(code: string, message: string, meta?: {
+        sqlState?: string;
+        errno?: number;
+        status?: number;
+    });
+}

package/dist/types/errors/MySQLConnectionError.d.ts

@@ -0,0 +1,4 @@
+export declare class MySQLConnectionError {
+    constructor();
+    static handleMysqlConnectionError(error: unknown): never;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,13 @@
+export { CredentialsConnection } from './types/CredentialsConnection';
+export { CoreSqlTypes } from './enums/CoreSqlTypes';
+export { Recorset } from './types/RecordSet';
+export { DBConnector } from "./DBConnector";
+export { DBSQLType } from "./types/DBSQLTypes";
+export { DBNoSQLType } from "./types/DBNoSQLTypes";
+export { NoSQLConnector } from "./abstract/NoSQLConnector";
+export { SqlConnector, Filter } from "./abstract/SQLConnector";
+export { NoSQLOptions } from "./types/NoSQLOptions";
+export { Document, Model, Schema, UpdateQuery, FilterQuery, ClientSession, PipelineStage, SortOrder, AggregateOptions } from 'mongoose';
+export { Model as ModelSequelize, Sequelize, DataTypes, CreateOptions, UpdateOptions, DestroyOptions, FindOptions, Attributes, WhereOptions, QueryOptions, InferAttributes, CreationAttributes, InferCreationAttributes, QueryTypes, QueryOptionsWithType, Transaction, Op, fn } from "sequelize";
+export { DBError } from "./errors/DBError";
+export { MySQLConnectionError } from "./errors/MySQLConnectionError";

package/dist/types/managers/NoSQLConnectionManager.d.ts

@@ -0,0 +1,6 @@
+import { NoSQLConnector } from "../abstract/NoSQLConnector";
+import { CredentialsConnection } from "../types/CredentialsConnection";
+import { DBNoSQLType } from "../types/DBNoSQLTypes";
+export declare class NoSQLConnectionManager {
+    static getInstance(type: DBNoSQLType, credentials: CredentialsConnection): NoSQLConnector;
+}

package/dist/types/managers/SQLConnectionManager.d.ts

@@ -0,0 +1,6 @@
+import { SqlConnector } from "../abstract/SQLConnector";
+import { CredentialsConnection } from "../types/CredentialsConnection";
+import { DBSQLType } from "../types/DBSQLTypes";
+export declare class SQLConnectionManager {
+    static getInstance(type: DBSQLType, credentials: CredentialsConnection): SqlConnector;
+}

package/dist/types/types/CredentialsConnection.d.ts

@@ -0,0 +1,12 @@
+export interface CredentialsConnection {
+    host: string;
+    user?: string;
+    password?: string;
+    database: string;
+    port?: number;
+    timeOut?: number;
+    options?: object;
+    instance?: string;
+    dialect?: 'mysql' | 'postgres' | 'sqlite' | 'mariadb' | 'mssql';
+    logging?: boolean;
+}

package/dist/types/types/DBNoSQLTypes.d.ts

@@ -0,0 +1,4 @@
+export declare enum DBNoSQLType {
+    MongoDB = "MongoDB",
+    Cassandra = "Cassandra"
+}

package/dist/types/types/DBSQLTypes.d.ts

@@ -0,0 +1,4 @@
+export declare enum DBSQLType {
+    SQLServer = "SQLServer",
+    MYSQL = "MYSQL"
+}

package/dist/types/types/NoSQLOptions.d.ts

@@ -0,0 +1,7 @@
+import { SortOrder } from "mongoose";
+export interface NoSQLOptions {
+    limit?: number;
+    skip?: number;
+    sort?: Record<string, SortOrder>;
+    select?: string | string[] | Record<string, number | boolean | string | object>;
+}

package/dist/types/types/RecordSet.d.ts

@@ -0,0 +1,6 @@
+import { CoreSqlTypes } from '../enums/CoreSqlTypes';
+export type Recorset = {
+    id: string;
+    value: unknown;
+    type?: CoreSqlTypes;
+};

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@hemia/db-connector",
+  "version": "0.0.1",
+  "description": "Hemia Database Conector",
+  "main": "dist/hemia-db-connector.js",
+  "module": "dist/hemia-db-connector.esm.js",
+  "types": "dist/types/index.d.ts",
+  "scripts": {
+    "clean": "rimraf dist",
+    "tscBuild": "rollup -c",
+    "build": "npm run clean && npm run tscBuild",
+    "coverage": "nyc npm run test",
+    "prepublishOnly": "npm run build",
+    "test": "jest --detectOpenHandles",
+    "test:coverage": "jest --coverage",
+    "test:watch": "jest --watch"
+  },
+  "nyc": {
+    "reporter": [
+      "lcov",
+      "text"
+    ],
+    "include": [
+      "src/**/*.ts"
+    ],
+    "exclude": [
+      "test/**/*.ts"
+    ]
+  },
+  "keywords": [
+    "hemia",
+    "database",
+    "connector",
+    "mongoose",
+    "mssql",
+    "mysql",
+    "sequelize",
+    "typescript"
+  ],
+  "author": "Hemia Technologies",
+  "license": "MIT",
+  "dependencies": {
+    "eslint": "^9.21.0",
+    "mongoose": "^8.8.2",
+    "rollup-plugin-visualizer": "^5.12.0"
+  },
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^26.0.1",
+    "@rollup/plugin-json": "^6.1.0",
+    "@rollup/plugin-node-resolve": "^15.2.3",
+    "@types/chai": "^4.3.17",
+    "@types/mocha": "^10.0.7",
+    "@types/mssql": "^9.1.5",
+    "@types/node": "^22.3.0",
+    "@typescript-eslint/eslint-plugin": "^8.5.0",
+    "@types/jest": "^29.5.14",
+    "chai": "^4.2.0",
+    "events": "^3.3.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.2.5",
+    "mocha": "^10.7.3",
+    "mssql": "^11.0.1",
+    "mysql2": "^3.11.0",
+    "rimraf": "^6.0.1",
+    "rollup": "^4.20.0",
+    "rollup-plugin-typescript2": "^0.36.0",
+    "sequelize": "^6.37.3",
+    "ts-node": "^8.9.0",
+    "typescript": "^5.5.4"
+  },
+  "overrides": {
+    "glob": "10.4.2"
+  },
+  "files": [
+    "dist"
+  ]
+}