uranio 0.1.19 → 0.1.21

package/.uranio/.infisical.json

@@ -0,0 +1,5 @@
+{
+    "workspaceId": "65a68e448163bda9cbdc7680",
+    "defaultEnvironment": "",
+    "gitBranchToEnvironmentMapping": null
+}

package/.uranio/package.json

@@ -3,12 +3,17 @@
   "main": "dist/index.js",
   "scripts": {
     "build": "yarn tsc -b",
-    "dev": "yarn tsc -w"
+    "dev": "yarn tsc -w",
+    "dev:base": "infisical run --env=dev -- node -r source-map-support/register -r dotenv/config ./dist/run.js",
+    "dev:run": "infisical run --env=dev -- yarn tsc-watch --onSuccess \"yarn dev:base\"",
+    "dev:test": "infisical run --env=dev -- node --import tsx --test --test-reporter spec --watch ./tests/*.test.ts",
+    "test": "infisical run --env=dev -- node --no-warnings --import tsx --test --test-reporter spec tests/**/*test.ts"
   },
   "devDependencies": {
     "@types/node": "^20.9.0",
     "@typescript-eslint/eslint-plugin": "^5.59.1",
     "@typescript-eslint/parser": "^5.59.1",
+    "dotenv": "^16.3.1",
     "eslint": "^8.39.0",
     "eslint-config-prettier": "^8.8.0",
     "eslint-plugin-import": "^2.27.5",
@@ -16,10 +21,13 @@
     "eslint-plugin-json": "^3.1.0",
     "eslint-plugin-node": "^11.1.0",
     "eslint-plugin-promise": "^6.1.1",
+    "prettier": "^3.1.1",
+    "source-map-support": "^0.5.21",
     "tsc-watch": "^6.0.0",
+    "tsx": "^4.7.0",
     "typescript": "^5.2.2"
   },
   "dependencies": {
-    "uranio": "0.1.19"
+    "uranio": "0.1.21"
   }
 }

package/.uranio/src/{atom.ts → atom/mongodb.ts}

@@ -1,24 +1,28 @@
 /**
  *
- * Atom client module
+ * MongoDB Atom client module
  *
  */
 
 import mongodb, {ObjectId} from 'mongodb';
 
-import {atom, Query, Shape} from './types';
+import * as t from '../types/index';
 
-export class AtomClient<S extends atom> {
+// export class MongoDBAtomClient<S extends atom> implements AtomClient<S> {
+export class MongoDBAtomClient<S extends t.mongodb_atom> {
 
   public collection: mongodb.Collection<S>;
 
-  constructor(private db: mongodb.Db, public name: string) {
+  constructor(
+    private db: mongodb.Db,
+    public name: string
+  ) {
     this.collection = this.db.collection<S>(name);
   }
 
-  public async get_item(query: Query<S>): Promise<S | null> {
-    query = _instance_object_id(query);
-    let item = await this.collection.findOne<S>(query as mongodb.Filter<S>);
+  public async get_atom(where: t.Where<S>): Promise<S | null> {
+    where = _instance_object_id(where);
+    let item = await this.collection.findOne<S>(where as mongodb.Filter<S>);
     if (!item) {
       return null;
     }
@@ -26,10 +30,10 @@ export class AtomClient<S extends atom> {
     return item;
   }
 
-  public async get_items(query: Query<S>): Promise<S[]> {
-    query = _instance_object_id(query);
+  public async get_atoms(where: t.Where<S>): Promise<S[]> {
+    where = _instance_object_id(where);
     let items = await this.collection
-      .find<S>(query as mongodb.Filter<S>)
+      .find<S>(where as mongodb.Filter<S>)
       .toArray();
     for (let item of items) {
       item = _string_id(item) as S;
@@ -37,7 +41,7 @@ export class AtomClient<S extends atom> {
     return items;
   }
 
-  public async put_item(shape: Shape<S>): Promise<mongodb.InsertOneResult> {
+  public async put_atom(shape: t.Shape<S>): Promise<mongodb.InsertOneResult> {
     shape = _remove_id(shape as Partial<S>);
     const respone_insert = await this.collection.insertOne(
       shape as mongodb.OptionalUnlessRequiredId<S>
@@ -45,7 +49,7 @@ export class AtomClient<S extends atom> {
     return respone_insert;
   }
 
-  public async put_items(atoms: Shape<S>[]): Promise<mongodb.InsertManyResult> {
+  public async put_atoms(atoms: t.Shape<S>[]): Promise<mongodb.InsertManyResult> {
     const atoms_no_ids: mongodb.OptionalUnlessRequiredId<S>[] = [];
     for (const atom of atoms) {
       const atom_no_id = _remove_id(
@@ -57,44 +61,44 @@ export class AtomClient<S extends atom> {
     return items;
   }
 
-  public async update_item(
-    query: Query<S>,
+  public async update_atom(
+    where: t.Where<S>,
     atom: Partial<S>
   ): Promise<mongodb.UpdateResult> {
-    query = _instance_object_id(query);
+    where = _instance_object_id(where);
     atom = _remove_id(atom) as Partial<S>;
     const response_update = await this.collection.updateOne(
-      query as mongodb.Filter<S>,
+      where as mongodb.Filter<S>,
       {$set: atom}
     );
     return response_update;
   }
 
-  public async update_items(
-    query: Query<S>,
+  public async update_atoms(
+    where: t.Where<S>,
     atom: Partial<S>
   ): Promise<mongodb.UpdateResult> {
-    query = _instance_object_id(query);
+    where = _instance_object_id(where);
     atom = _remove_id(atom) as Partial<S>;
     const response_update = await this.collection.updateMany(
-      query as mongodb.Filter<S>,
+      where as mongodb.Filter<S>,
       {$set: atom}
     );
     return response_update;
   }
 
-  public async delete_item(query: Query<S>): Promise<mongodb.DeleteResult> {
-    query = _instance_object_id(query);
+  public async delete_atom(where: t.Where<S>): Promise<mongodb.DeleteResult> {
+    where = _instance_object_id(where);
     const response_delete = await this.collection.deleteOne(
-      query as mongodb.Filter<S>
+      where as mongodb.Filter<S>
     );
     return response_delete;
   }
 
-  public async delete_items(query: Query<S>): Promise<mongodb.DeleteResult> {
-    query = _instance_object_id(query);
+  public async delete_atoms(where: t.Where<S>): Promise<mongodb.DeleteResult> {
+    where = _instance_object_id(where);
     const response_delete = await this.collection.deleteMany(
-      query as mongodb.Filter<S>
+      where as mongodb.Filter<S>
     );
     return response_delete;
   }
@@ -114,19 +118,19 @@ function _string_id<T extends unknown>(item: T): StringId<T> {
   return item as StringId<T>;
 }
 
-function _remove_id<A extends atom>(atom: Partial<A>): Shape<A> {
+function _remove_id<A extends t.mongodb_atom>(atom: Partial<A>): t.Shape<A> {
   delete (atom as any)._id;
-  return atom as Shape<A>;
+  return atom as t.Shape<A>;
 }
 
-function _instance_object_id<A extends atom>(query: Query<A>): Query<A> {
-  for (let [key, value] of Object.entries(query)) {
+function _instance_object_id<A extends t.mongodb_atom>(where: t.Where<A>): t.Where<A> {
+  for (let [key, value] of Object.entries(where)) {
     if (key === '_id' && typeof value === 'string') {
-      query['_id'] = new ObjectId(value) as any;
+      where['_id'] = new ObjectId(value) as any;
     }
     if (value && typeof value === 'object') {
       value = _instance_object_id(value);
     }
   }
-  return query;
+  return where;
 }

package/.uranio/src/atom/mysql.ts

@@ -0,0 +1,112 @@
+/**
+ *
+ * MySQL Atom client module
+ *
+ */
+
+// import mysql from 'mysql2/promise';
+
+// import {log} from './log/index';
+
+import {MySQLClient} from '../client/mysql';
+
+import * as sql from '../sql/index';
+import * as t from '../types/index';
+
+// export class MySQLAtomClient<S extends t.atom> implements t.AtomClient<S> {
+
+export class MySQLAtomClient<S extends t.mysql_atom> {
+
+  constructor(
+    public client: MySQLClient,
+    public name: string
+  ) {}
+
+  public async get_atom(where: t.Where<S>): Promise<S | null> {
+    const {query, map} = sql.param.compose_select({
+      table: this.name,
+      where,
+      limit: 'LIMIT 1',
+    });
+    const [rows] = await this.client.exe(query, map);
+    if (Array.isArray(rows) && rows[0]) {
+      return rows[0] as S;
+    }
+    return null;
+  }
+
+  public async get_atoms({
+    where,
+    order,
+    limit,
+  }: {
+    where?: t.Where<S>;
+    order?: t.OrderBy;
+    limit?: string;
+  }): Promise<S[]> {
+    const {query, map} = sql.param.compose_select({
+      table: this.name,
+      where,
+      order,
+      limit,
+    });
+    const [rows] = await this.client.exe(query, map);
+    if (Array.isArray(rows)) {
+      return rows as S[];
+    }
+    return [];
+  }
+
+  public async put_atom(shape: Partial<S>): Promise<any> {
+    const columns:(keyof S)[] = [];
+    for(const [key, _] of Object.entries(shape)){
+      columns.push(key as keyof S);
+    }
+    const {query, query_records} = sql.param.compose_insert({
+      table: this.name,
+      columns,
+      records: [shape]
+    });
+    const response = await this.client.exe(query, query_records);
+    return response;
+  }
+
+  public async put_atoms(shapes: Partial<S>[]): Promise<any> {
+    const columns:(keyof S)[] = [];
+    if(!Array.isArray(shapes) || shapes.length < 1 || !shapes[0]){
+      return null;
+    }
+    for(const [key, _] of Object.entries(shapes[0])){
+      columns.push(key as keyof S);
+    }
+    const {query, query_records} = sql.param.compose_insert({
+      table: this.name,
+      columns,
+      records: shapes
+    });
+    const response = await this.client.exe(query, query_records);
+    return response;
+  }
+
+  public async update_atoms(
+    atom: Partial<S>,
+    where?: t.Where<S>,
+  ): Promise<any> {
+    const {query, map} = sql.param.compose_update({
+      table: this.name,
+      where,
+      update: atom
+    });
+    const response = await this.client.exe(query, map);
+    return response;
+  }
+
+  public async delete_atoms(where: t.Where<S>): Promise<any> {
+    const {query, map} = sql.param.compose_delete({
+      table: this.name,
+      where,
+    });
+    const response = await this.client.exe(query, map);
+    return response;
+  }
+}

package/.uranio/src/client/mongodb.ts

@@ -0,0 +1,40 @@
+/**
+ *
+ * MongoDB Client module
+ *
+ * @packageDocumentation
+ *
+ */
+
+import mongodb, {MongoClient, ServerApiVersion} from 'mongodb';
+import {log} from '../log/index';
+
+export type MongoDBClientParams = {
+  uri: string;
+  db_name: string;
+};
+
+export class MongoDBClient{
+  protected client: mongodb.MongoClient;
+  protected db: mongodb.Db;
+  constructor(params: MongoDBClientParams) {
+    this.client = new MongoClient(params.uri, {
+      serverApi: {
+        version: ServerApiVersion.v1,
+        strict: true,
+        deprecationErrors: true,
+      },
+    });
+    this.db = this.client.db(params.db_name);
+  }
+  public async connect() {
+    log.trace('Connecting...');
+    await this.client.connect();
+    log.trace('Connected.');
+  }
+  public async disconnect() {
+    log.trace('Disconnecting...');
+    await this.client.close();
+    log.trace('Disconnected.');
+  }
+}

package/.uranio/src/client/mysql.ts

@@ -0,0 +1,71 @@
+/**
+ *
+ * MySQL Client module
+ *
+ * @packageDocumentation
+ *
+ */
+
+import mysql from 'mysql2/promise';
+import {log} from '../log/index';
+
+export type MySQLClientParams = {
+  uri: string;
+  use_pool?: boolean;
+};
+
+export class MySQLClient {
+  public pool?: mysql.Pool;
+  public main_connection: mysql.Connection | undefined;
+  protected uri: string;
+  constructor(params: MySQLClientParams) {
+    this.uri = params.uri;
+    if (params.use_pool === true) {
+      this.pool = mysql.createPool({
+        uri: params.uri,
+        namedPlaceholders: true,
+      });
+    }
+  }
+  public async exe(sql: string, values?: any) {
+    const with_values =
+      typeof values !== 'undefined'
+        ? ` with values [${Object.entries(values)}]`
+        : '';
+    log.trace(`Excuting query '${sql}'${with_values}...`);
+    if (this.pool) {
+      return await this._execute_from_pool_connection(sql, values);
+    }
+    if (!this.main_connection) {
+      await this.connect();
+    }
+    const [rows, fields] = await this.main_connection!.execute(sql, values);
+    return [rows, fields];
+  }
+  public async connect() {
+    log.trace(`Connecting to MySQL database...`);
+    this.main_connection = await mysql.createConnection({
+      uri: this.uri,
+      namedPlaceholders: true,
+    });
+    log.debug(`Connected to MySQL database`);
+  }
+  public async disconnect() {
+    log.trace(`Disconnecting from MySQL database...`);
+    await this.main_connection?.end();
+    log.debug(`Disconnected from MySQL database`);
+  }
+  private async _execute_from_pool_connection(sql: string, values?: any) {
+    if (!this.pool) {
+      throw new Error(`Pool was not initialized`);
+    }
+    log.trace(`Retrieving pool connection...`);
+    const pool_connection = await this.pool.getConnection();
+    log.trace(`[${pool_connection.threadId}] Retrieved pool connection`);
+    const [rows, fields] = await pool_connection.execute(sql, values);
+    log.trace(`Releasing pool connection...`);
+    pool_connection.release();
+    log.trace(`[${pool_connection.threadId}] Released pool connection`);
+    return [rows, fields];
+  }
+}

package/.uranio/src/client.ts

@@ -1,40 +1,43 @@
 /**
  *
- * Client module
+ * UranioClient module
  *
  * @packageDocumentation
  *
  */
 
-import mongodb, {MongoClient, ServerApiVersion} from 'mongodb';
-import {log} from './log/index';
+import {MongoDBClient, MongoDBClientParams} from './client/mongodb';
+import {MySQLClient, MySQLClientParams} from './client/mysql';
 
-export type ClientParams = {
-  uri: string;
-  db_name: string;
+import {MongoDBAtomClient} from './atom/mongodb';
+import {MySQLAtomClient} from './atom/mysql';
+
+import * as t from './types/index';
+
+type MongoPippo = {
+  _id: t.primary<string>;
+  age: number;
+  name: string;
 };
 
-export class Client{
-  protected client: mongodb.MongoClient;
-  protected db: mongodb.Db;
-  constructor(params: ClientParams) {
-    this.client = new MongoClient(params.uri, {
-      serverApi: {
-        version: ServerApiVersion.v1,
-        strict: true,
-        deprecationErrors: true,
-      },
-    });
-    this.db = this.client.db(params.db_name);
-  }
-  public async connect() {
-    log.trace('Connecting...');
-    await this.client.connect();
-    log.trace('Connected.');
+type MySQLPippo = {
+  id: t.primary<number>;
+  age: number;
+  name: string;
+};
+
+export class UranioMongoDBClient extends MongoDBClient {
+  public pippo: MongoDBAtomClient<MongoPippo>;
+  constructor(params: MongoDBClientParams) {
+    super(params);
+    this.pippo = new MongoDBAtomClient<MongoPippo>(this.db, 'pippo');
   }
-  public async disconnect() {
-    log.trace('Disconnecting...');
-    await this.client.close();
-    log.trace('Disconnected.');
+}
+
+export class UranioMySQLClient extends MySQLClient {
+  public pippo: MySQLAtomClient<MySQLPippo>;
+  constructor(params: MySQLClientParams) {
+    super(params);
+    this.pippo = new MySQLAtomClient<MySQLPippo>(this, 'pippo');
   }
 }

package/.uranio/src/index.ts

@@ -6,7 +6,10 @@
  *
  */
 
-export * from './types';
+export * from './types/index';
 
-import {UranioClient as Client} from './uranio-client';
-export {Client};
+import {UranioMongoDBClient as MongoDBClient} from './client';
+export {MongoDBClient};
+
+import {UranioMySQLClient as MySQLClient} from './client';
+export {MySQLClient};

package/.uranio/src/run.ts

@@ -0,0 +1,7 @@
+/**
+ *
+ * Run module
+ *
+ * @packageDocumentation
+ *
+ */