@medyll/idae-db 0.0.1

package/README.md

@@ -0,0 +1,58 @@
+# create-svelte
+
+Everything you need to build a Svelte library, powered by [`create-svelte`](https://github.com/sveltejs/kit/tree/main/packages/create-svelte).
+
+Read more about creating a library [in the docs](https://kit.svelte.dev/docs/packaging).
+
+## Creating a project
+
+If you're seeing this, you've probably already done this step. Congrats!
+
+```bash
+# create a new project in the current directory
+npm create svelte@latest
+
+# create a new project in my-app
+npm create svelte@latest my-app
+```
+
+## Developing
+
+Once you've created a project and installed dependencies with `npm install` (or `pnpm install` or `yarn`), start a development server:
+
+```bash
+npm run dev
+
+# or start the server and open the app in a new browser tab
+npm run dev -- --open
+```
+
+Everything inside `src/lib` is part of your library, everything inside `src/routes` can be used as a showcase or preview app.
+
+## Building
+
+To build your library:
+
+```bash
+npm run package
+```
+
+To create a production version of your showcase app:
+
+```bash
+npm run build
+```
+
+You can preview the production build with `npm run preview`.
+
+> To deploy your app, you may need to install an [adapter](https://kit.svelte.dev/docs/adapters) for your target environment.
+
+## Publishing
+
+Go into the `package.json` and give your package the desired name through the `"name"` option. Also consider adding a `"license"` field and point it to a `LICENSE` file which you can create from a template (one popular option is the [MIT license](https://opensource.org/license/mit/)).
+
+To publish your library to [npm](https://www.npmjs.com):
+
+```bash
+npm publish
+```

package/dist/IdaeDBModel.d.ts

@@ -0,0 +1,12 @@
+import { Collection, Document } from "mongodb";
+import { IdaeDbConnection } from "./IdaeDbConnection";
+export declare class IdaeDBModel<T extends Document> {
+    private _collection;
+    private _autoIncrementField;
+    private _fieldId;
+    constructor(connection: IdaeDbConnection, collectionName: string, options?: {
+        autoIncrementFormat?: (collection: string) => string;
+    });
+    get collection(): Collection<T>;
+    get fieldId(): string | undefined;
+}

package/dist/IdaeDBModel.js

@@ -0,0 +1,19 @@
+// packages\idae-db\lib\IdaeDBModel.ts
+import { Collection, Document } from "mongodb";
+import { IdaeDbConnection } from "./IdaeDbConnection";
+export class IdaeDBModel {
+    _collection;
+    _autoIncrementField = undefined;
+    _fieldId = "_id";
+    constructor(connection, collectionName, options) {
+        this._collection = connection.getDb().collection(collectionName);
+        this._autoIncrementField = options?.autoIncrementFormat?.(collectionName);
+        this._fieldId = this._autoIncrementField ?? "_id";
+    }
+    get collection() {
+        return this._collection;
+    }
+    get fieldId() {
+        return this._fieldId;
+    }
+}

package/dist/IdaeDbConnection.d.ts

@@ -0,0 +1,16 @@
+import { Db } from "mongodb";
+import { Connection as MysqlConnection } from "mysql2/promise";
+import { DbType } from "./types";
+export declare class IdaeDbConnection {
+    private uri;
+    private dbName;
+    private dbType;
+    private mongoClient;
+    private mongoDb;
+    private mysqlConnection;
+    constructor(uri: string, dbName: string, dbType: DbType);
+    connect(): Promise<void>;
+    getDb(): Db | MysqlConnection;
+    close(): Promise<void>;
+    getDbType(): DbType;
+}

package/dist/IdaeDbConnection.js

@@ -0,0 +1,74 @@
+// packages\idae-db\lib\IdaeDbConnection.ts
+import { MongoClient, Db } from "mongodb";
+import { Connection as MysqlConnection } from "mysql2/promise";
+import { DbType } from "./types";
+export class IdaeDbConnection {
+    uri;
+    dbName;
+    dbType;
+    mongoClient = null;
+    mongoDb = null;
+    mysqlConnection = null;
+    constructor(uri, dbName, dbType) {
+        this.uri = uri;
+        this.dbName = dbName;
+        this.dbType = dbType;
+    }
+    async connect() {
+        try {
+            switch (this.dbType) {
+                case DbType.MONGODB:
+                    this.mongoClient = new MongoClient(this.uri);
+                    await this.mongoClient.connect();
+                    this.mongoDb = this.mongoClient.db(this.dbName);
+                    console.log("Connected to MongoDB");
+                    break;
+                case DbType.MYSQL:
+                    // this.mysqlConnection = await mysql.createConnection(...);
+                    console.log("Connected to MySQL");
+                    break;
+                default:
+                    throw new Error(`Unsupported database type: ${this.dbType}`);
+            }
+        }
+        catch (error) {
+            console.error(`Error connecting to ${this.dbType}:`, error);
+            throw error;
+        }
+    }
+    getDb() {
+        switch (this.dbType) {
+            case DbType.MONGODB:
+                if (!this.mongoDb) {
+                    throw new Error("MongoDB not connected. Call connect() first.");
+                }
+                return this.mongoDb;
+            case DbType.MYSQL:
+                if (!this.mysqlConnection) {
+                    throw new Error("MySQL not connected. Call connect() first.");
+                }
+                return this.mysqlConnection;
+            default:
+                throw new Error(`Unsupported database type: ${this.dbType}`);
+        }
+    }
+    async close() {
+        switch (this.dbType) {
+            case DbType.MONGODB:
+                if (this.mongoClient) {
+                    await this.mongoClient.close();
+                    console.log("Disconnected from MongoDB");
+                }
+                break;
+            case DbType.MYSQL:
+                if (this.mysqlConnection) {
+                    await this.mysqlConnection.end();
+                    console.log("Disconnected from MySQL");
+                }
+                break;
+        }
+    }
+    getDbType() {
+        return this.dbType;
+    }
+}

package/dist/adapters/MongoDBAdapter.d.ts

@@ -0,0 +1,20 @@
+import type { IdaeDbParams, IdaeDbAdapter } from "../types.js";
+import { Document, type IndexSpecification, type CreateIndexesOptions } from "mongodb";
+import { IdaeDbConnection } from "../IdaeDbConnection.js";
+export declare class MongoDBAdapter<T extends Document> implements IdaeDbAdapter<T> {
+    private model;
+    private connection;
+    private fieldId;
+    constructor(collection: string, connection: IdaeDbConnection);
+    createIndex(fieldOrSpec: IndexSpecification, options?: CreateIndexesOptions): Promise<string>;
+    findById(id: string): Promise<import("mongodb").FindCursor<import("mongodb").WithId<T>>>;
+    find(params: IdaeDbParams<T>): Promise<import("mongodb").FindCursor<import("mongodb").WithId<T>>>;
+    findOne(params: IdaeDbParams<T>): Promise<import("mongodb").WithId<T> | null>;
+    update(id: string, updateData: Partial<T>): Promise<import("mongodb").UpdateResult<T>>;
+    updateWhere(params: IdaeDbParams<T>, updateData: Partial<T>): Promise<import("mongodb").UpdateResult<T>>;
+    deleteById(id: string): Promise<import("mongodb").DeleteResult>;
+    deleteWhere(params: IdaeDbParams<T>): Promise<{
+        deletedCount?: number;
+    }>;
+    private parseSortOptions;
+}

package/dist/adapters/MongoDBAdapter.js

@@ -0,0 +1,66 @@
+// packages\idae-db\src\lib\adapters\MongoDBAdapter.ts
+import dotenv from "dotenv";
+import { Document, } from "mongodb";
+import { IdaeDbConnection } from "../IdaeDbConnection.js";
+import { IdaeDBModel } from "../IdaeDBModel.js";
+// Load environment variables
+dotenv.config();
+// MongoDB Adapter
+export class MongoDBAdapter {
+    model;
+    connection;
+    fieldId;
+    constructor(collection, connection) {
+        // just in case
+        collection = collection.split(".")[1] ?? collection.split(".")[0];
+        this.connection = connection;
+        this.model = this.connection.model(collection);
+        this.fieldId = this.model.fieldId;
+    }
+    async createIndex(fieldOrSpec, options) {
+        return this.model.collection.createIndex(fieldOrSpec, options);
+    }
+    async findById(id) {
+        return this.model.collection.find({ [this.fieldId]: id }, { hint: this.fieldId });
+    }
+    async find(params) {
+        const { query = {}, sortBy, limit, skip } = params;
+        const sortOptions = this.parseSortOptions(sortBy);
+        return await this.model.collection
+            .find(query)
+            .sort(sortOptions)
+            .limit(Number(limit) || 0)
+            .skip(Number(skip) || 0);
+    }
+    findOne(params) {
+        return this.model.collection.findOne(params.query);
+    }
+    async update(id, updateData) {
+        return this.model.collection.updateMany({ [this.fieldId]: id }, updateData, {
+            upsert: true,
+        });
+    }
+    async updateWhere(params, updateData) {
+        return this.model.collection.updateMany(params.query, updateData, {
+            upsert: true,
+        });
+    }
+    async deleteById(id) {
+        return this.model.collection.deleteMany({ _id: { $eq: id } });
+    }
+    async deleteWhere(params) {
+        const result = await this.model.collection.deleteMany(params.query);
+        return { deletedCount: result.deletedCount };
+    }
+    parseSortOptions(sortBy) {
+        const sortOptions = {};
+        if (sortBy) {
+            const sortFields = sortBy.split(",");
+            sortFields.forEach((field) => {
+                const [key, order] = field.split(":");
+                sortOptions[key] = order === "desc" ? -1 : 1;
+            });
+        }
+        return sortOptions;
+    }
+}

package/dist/adapters/MySQLAdapter.d.ts

@@ -0,0 +1,23 @@
+import type { ApiServerRequestParams } from "../server/engine/types";
+import { Model } from "sequelize";
+import type { DatabaseAdapter } from "../types";
+interface MySQLDocument extends Model {
+    id: number;
+    [key: string]: any;
+}
+export declare class MySQLAdapter<T extends MySQLDocument> implements DatabaseAdapter<T> {
+    private sequelize;
+    private model;
+    constructor(tableName: string);
+    create(document: Partial<T>): Promise<T>;
+    where(params: ApiServerRequestParams): Promise<T[]>;
+    findById(id: string): Promise<T | null>;
+    findOne(params: ApiServerRequestParams): Promise<T | null>;
+    update(id: string, updateData: Partial<T>): Promise<T | null>;
+    deleteById(id: string): Promise<T | null>;
+    deleteManyByQuery(params: ApiServerRequestParams): Promise<{
+        deletedCount?: number;
+    }>;
+    private parseSortOptions;
+}
+export {};

package/dist/adapters/MySQLAdapter.js

@@ -0,0 +1,80 @@
+import { Sequelize, Model, DataTypes } from "sequelize";
+import dotenv from "dotenv";
+dotenv.config();
+export class MySQLAdapter {
+    sequelize;
+    model;
+    constructor(tableName) {
+        this.sequelize = new Sequelize({
+            dialect: "mysql",
+            host: process.env.MYSQL_HOST || "localhost",
+            port: Number(process.env.MYSQL_PORT) || 3306,
+            database: process.env.MYSQL_DATABASE || "database",
+            username: process.env.MYSQL_USER || "root",
+            password: process.env.MYSQL_PASSWORD || "password",
+        });
+        this.model = this.sequelize.define(tableName, {
+            id: {
+                type: DataTypes.INTEGER.UNSIGNED,
+                autoIncrement: true,
+                primaryKey: true,
+            },
+            // Define other fields here as needed
+        }, {
+            timestamps: false,
+            tableName,
+        });
+    }
+    async create(document) {
+        const newDocument = await this.model.create(document);
+        return newDocument;
+    }
+    async where(params) {
+        const { query = {}, sortBy, limit, skip } = params;
+        const options = {
+            where: query,
+            order: this.parseSortOptions(sortBy),
+            limit: limit ? Number(limit) : undefined,
+            offset: skip ? Number(skip) : undefined,
+        };
+        const results = await this.model.findAll(options);
+        return results;
+    }
+    async findById(id) {
+        const result = await this.model.findByPk(id);
+        return result ? result : null;
+    }
+    async findOne(params) {
+        const { query = {} } = params;
+        const result = await this.model.findOne({ where: query });
+        return result ? result : null;
+    }
+    async update(id, updateData) {
+        const [affectedCount, affectedRows] = await this.model.update(updateData, {
+            where: { id },
+            returning: true,
+        });
+        return affectedCount > 0 ? affectedRows[0] : null;
+    }
+    async deleteById(id) {
+        const result = await this.model.findByPk(id);
+        if (result) {
+            await result.destroy();
+            return result;
+        }
+        return null;
+    }
+    async deleteManyByQuery(params) {
+        const { query = {} } = params;
+        const deletedCount = await this.model.destroy({ where: query });
+        return { deletedCount };
+    }
+    parseSortOptions(sortBy) {
+        if (!sortBy)
+            return [];
+        return sortBy.split(",").map((field) => {
+            const [key, order] = field.split(":");
+            return [key, order === "desc" ? "DESC" : "ASC"];
+        });
+    }
+}

package/dist/idaDb.d.ts

@@ -0,0 +1,17 @@
+import { DbType } from "./types.js";
+import { IdaeDbConnection } from "./IdaeDbConnection";
+import { MongoDBAdapter } from "./adapters/MongoDBAdapter";
+import { MySQLAdapter } from "./adapters/MysqlAdapter";
+import type { Document } from "mongodb";
+export declare class IdaeDb {
+    private static instances;
+    private connections;
+    private dbType;
+    private constructor();
+    static getOrCreateInstance(dbType: DbType): IdaeDb;
+    createConnection(connectionName: string, uri: string, dbName: string): Promise<IdaeDbConnection>;
+    getConnection(connectionName: string): IdaeDbConnection;
+    getAdapter<T extends Document>(connectionName: string, collectionName: string): MongoDBAdapter<T> | MySQLAdapter<T>;
+    closeConnection(connectionName: string): Promise<void>;
+    closeAllConnections(): Promise<void>;
+}

package/dist/idaDb.js

@@ -0,0 +1,59 @@
+// packages\idae-db\lib\idaDb.ts
+import { DbType } from "./types.js";
+import { IdaeDbConnection } from "./IdaeDbConnection";
+import { MongoDBAdapter } from "./adapters/MongoDBAdapter";
+import { MySQLAdapter } from "./adapters/MysqlAdapter";
+export class IdaeDb {
+    static instances = new Map();
+    connections = new Map();
+    dbType;
+    constructor(dbType) {
+        this.dbType = dbType;
+    }
+    static getOrCreateInstance(dbType) {
+        if (!IdaeDb.instances.has(dbType)) {
+            IdaeDb.instances.set(dbType, new IdaeDb(dbType));
+        }
+        return IdaeDb.instances.get(dbType);
+    }
+    async createConnection(connectionName, uri, dbName) {
+        if (this.connections.has(connectionName)) {
+            throw new Error(`Connection '${connectionName}' already exists.`);
+        }
+        const connection = new IdaeDbConnection(uri, dbName, this.dbType);
+        await connection.connect();
+        this.connections.set(connectionName, connection);
+        return connection;
+    }
+    getConnection(connectionName) {
+        const connection = this.connections.get(connectionName);
+        if (!connection) {
+            throw new Error(`Connection '${connectionName}' not found.`);
+        }
+        return connection;
+    }
+    getAdapter(connectionName, collectionName) {
+        const connection = this.getConnection(connectionName);
+        switch (this.dbType) {
+            case DbType.MONGODB:
+                return new MongoDBAdapter(collectionName, connection);
+            case DbType.MYSQL:
+                return new MySQLAdapter(collectionName, connection);
+            default:
+                throw new Error(`Unsupported database type: ${this.dbType}`);
+        }
+    }
+    async closeConnection(connectionName) {
+        const connection = this.connections.get(connectionName);
+        if (connection) {
+            await connection.close();
+            this.connections.delete(connectionName);
+        }
+    }
+    async closeAllConnections() {
+        for (const [connectionName, connection] of this.connections) {
+            await connection.close();
+        }
+        this.connections.clear();
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './types.js';
+export * from './idaDb.js';
+export * from './IdaeDbConnection.js';
+export * from './IdaeDBModel.js';
+export * from './adapters/MySQLAdapter.js';
+export * from './adapters/MongoDBAdapter.js';

package/dist/index.js

@@ -0,0 +1,7 @@
+// auto exports of entry components
+export * from './types.js';
+export * from './idaDb.js';
+export * from './IdaeDbConnection.js';
+export * from './IdaeDBModel.js';
+export * from './adapters/MySQLAdapter.js';
+export * from './adapters/MongoDBAdapter.js';

package/dist/types.d.ts

@@ -0,0 +1,27 @@
+import { Document, type UpdateResult, type Filter, type WithId, type FindCursor, type IndexSpecification, type CreateIndexesOptions, type DeleteResult } from "mongodb";
+export interface IdaeDbAdapter<T extends Document> {
+    createIndex(fieldOrSpec: IndexSpecification, options?: CreateIndexesOptions): Promise<string>;
+    findById(id: string): Promise<FindCursor<WithId<T>>>;
+    find(params: IdaeDbParams<T>): Promise<FindCursor<WithId<T>>>;
+    findOne(params: IdaeDbParams<T>): Promise<WithId<T> | null>;
+    update(id: string, updateData: Partial<T>): Promise<UpdateResult<T>>;
+    updateWhere(params: IdaeDbParams<T>, updateData: Partial<T>): Promise<UpdateResult<T>>;
+    deleteById(id: string): Promise<DeleteResult>;
+    deleteWhere(params: IdaeDbParams<T>): Promise<{
+        deletedCount?: number;
+    }>;
+}
+export interface IdaeDbParams<T extends object> {
+    id?: string;
+    query: Filter<T>;
+    sortBy?: string;
+    limit?: number;
+    skip?: number;
+}
+export interface IdaeDbParamsSortOptions {
+    [key: string]: 1 | -1;
+}
+export declare enum DbType {
+    MONGODB = "mongodb",
+    MYSQL = "mysql"
+}

package/dist/types.js

@@ -0,0 +1,7 @@
+// packages\idae-db\src\lib\adapters\types.ts
+import { Document, } from "mongodb";
+export var DbType;
+(function (DbType) {
+    DbType["MONGODB"] = "mongodb";
+    DbType["MYSQL"] = "mysql";
+})(DbType || (DbType = {}));

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@medyll/idae-db",
+  "version": "0.0.1",
+  "scripts": {
+    "dev": "vite dev",
+    "build": "vite build && npm run package",
+    "preview": "vite preview",
+    "package": "svelte-kit sync && svelte-package && publint",
+    "prepublishOnly": "npm run package",
+    "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
+    "check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
+    "test": "vitest",
+    "lint": "prettier --check . && eslint .",
+    "format": "prettier --write .",
+    "package:pre": "node scripts/package-pre.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "svelte": "./dist/index.js",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.test.*",
+    "!dist/**/*.spec.*"
+  ],
+  "peerDependencies": {
+    "svelte": "^5.0.0-next"
+  },
+  "devDependencies": {
+    "@sveltejs/adapter-auto": "^3.2.4",
+    "@sveltejs/kit": "^2.5.24",
+    "@sveltejs/package": "^2.3.4",
+    "@sveltejs/vite-plugin-svelte": "^3.1.1",
+    "@types/eslint": "^9.6.0",
+    "eslint": "^9.9.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-svelte": "^2.43.0",
+    "globals": "^15.9.0",
+    "prettier": "^3.3.3",
+    "prettier-plugin-svelte": "^3.2.6",
+    "publint": "^0.2.10",
+    "svelte": "^5.0.0-next.225",
+    "svelte-check": "^3.8.5",
+    "typescript": "^5.5.4",
+    "typescript-eslint": "^8.1.0",
+    "vite": "^5.4.1",
+    "vitest": "^2.0.5"
+  },
+  "svelte": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "scope": "@medyll"
+}