uranio 0.1.19 → 0.1.21

package/.uranio/src/{query.ts → types/where.ts}

@@ -1,18 +1,21 @@
 /**
  *
- * Query type module
+ * Where type module
  *
  */
 
-import {atom} from './types';
+import {atom, primary} from './index';
 
-export type Query<A extends atom> = {
+export type Where<A extends atom> = {
   [P in keyof A]?: Condition<A[P]>;
 } & RootFilterOperators<A>;
 
 type Condition<T> = AlternativeType<T> | FilterOperators<AlternativeType<T>>;
 
-type AlternativeType<T> = T extends ReadonlyArray<infer U>
+type AlternativeType<T> =
+  T extends primary<infer P> ?
+  P | RegExpOrString<P> :
+  T extends ReadonlyArray<infer U>
   ? T | RegExpOrString<U>
   : RegExpOrString<T>;
 
@@ -41,9 +44,9 @@ interface FilterOperators<T> {
 }
 
 interface RootFilterOperators<A extends atom> {
-  $and?: Query<A>[];
-  $nor?: Query<A>[];
-  $or?: Query<A>[];
+  $and?: Where<A>[];
+  $nor?: Where<A>[];
+  $or?: Where<A>[];
   $text?: {
     $search: string;
     $language?: string;

package/.uranio/tests/client.mysql.test.ts

@@ -0,0 +1,130 @@
+import {describe, it, before} from 'node:test';
+import assert from 'node:assert';
+
+import mysql from 'mysql2/promise';
+
+import {UranioMySQLClient as MySQLClient} from '../src/client';
+
+import * as sql from '../src/sql/index';
+
+const mysql_uri = process.env.MYSQL_URI || '';
+
+type Pippo = {
+  _id: string
+}
+
+describe('MySQL Client Mocked', () => {
+
+  before(() => {});
+
+  it('should return the mocked rows MYSQL POOL', async () => {
+    const mysql_urn = new MySQLClient({
+      uri: mysql_uri,
+      use_pool: true
+    });
+    const mock_rows = [{ id: 1, name: 'John' }, {id: 2, name: 'Franco'}];
+    const mock_pool = {
+      getConnection: async () => {
+        return {
+          execute: async () => {
+            const fields = {};
+            return [mock_rows, fields];
+          },
+          threadId: 0,
+          release: () => {}
+        }
+      },
+    };
+    mysql_urn.pool = mock_pool as any;
+    const query = sql.full.compose_select<Pippo>({table: 'pippo'});
+    try{
+      const [rows_00] = await mysql_urn.exe(query);
+      assert.strictEqual(rows_00, mock_rows);
+    }catch(e){
+      const err = e as Error;
+     assert.fail(`Unexpected error: ${err.message}`); 
+    }finally{
+    }
+  });
+
+  it('should return the mocked rows MYSQL MAIN', async () => {
+    const mysql_urn = new MySQLClient({
+      uri: mysql_uri
+    });
+    const mock_rows = [{ id: 1, name: 'John' }, {id: 2, name: 'Franco'}];
+    const mock_create_connection = async () => {
+      return {
+        execute: async () => {
+          const fields = {};
+          return [mock_rows, fields];
+        },
+        end: () => {}
+      }
+    };
+    const original_create_connection = mysql.createConnection;
+    mysql.createConnection = mock_create_connection as any;
+    
+    const query = sql.full.compose_select<Pippo>({table: 'pippo'});
+    
+    try{
+      const [rows_00] = await mysql_urn.exe(query);
+      assert.strictEqual(rows_00, mock_rows);
+    }catch(e){
+      const err = e as Error;
+     assert.fail(`Unexpected error: ${err.message}`); 
+    }finally{
+      mysql.createConnection = original_create_connection;
+    }
+  });
+
+});
+
+describe('MySQL Client Integration Real DB', () => {
+
+  before(() => {});
+
+  it('should return the rows MYSQL POOL', async () => {
+    const mysql_urn = new MySQLClient({
+      uri: mysql_uri,
+      use_pool: true
+    });
+    const expected_row = {
+      age: 28,
+      email: 'john.doe@example.com',
+      id: 1,
+      name: 'John Doe',
+    };
+    const query = sql.full.compose_select<Pippo>({table: 'pippo'});
+    try{
+      const [rows_00] = await mysql_urn.exe(query);
+      assert.deepEqual(rows_00[0], expected_row);
+    }catch(e){
+      const err = e as Error;
+     assert.fail(`Unexpected error: ${err.message}`); 
+    }finally{
+    }
+  });
+
+  it('should return the rows MYSQL MAIN', async () => {
+    const mysql_urn = new MySQLClient({
+      uri: mysql_uri
+    });
+    const expected_row = {
+      age: 28,
+      email: 'john.doe@example.com',
+      id: 1,
+      name: 'John Doe',
+    };
+    const query = sql.full.compose_select<Pippo>({table: 'pippo'});
+    try{
+      const [rows_00] = await mysql_urn.exe(query);
+      assert.deepEqual(rows_00[0], expected_row);
+    }catch(e){
+      const err = e as Error;
+     assert.fail(`Unexpected error: ${err.message}`); 
+    }finally{
+      mysql_urn.disconnect();
+    }
+  });
+
+});

package/.uranio/tests/sql.full.test.ts

@@ -0,0 +1,185 @@
+import {describe, it} from 'node:test';
+import assert from 'node:assert';
+
+import * as sql from '../src/sql/index';
+
+type ATable = {
+  _id: string
+  foo: number
+  boo: string
+}
+
+describe('Testing SQL full query SELECT', () => {
+  it('should generate the same query SELECT', () => {
+    let final_query = '';
+    final_query += 'SELECT foo, boo FROM `a-table` WHERE';
+    final_query += ' `foo` > 2 AND `foo` <= 100 AND `boo` = "str"';
+    final_query += ' ORDER BY `foo` DESC';
+    final_query += ' LIMIT 10, 100';
+    const projection = ['foo', 'boo'];
+    const table = 'a-table';
+    const where = {foo: {$gt: 2, $lte: 100}, boo: 'str'};
+    const order = {foo: 'desc'} as const;
+    const limit = '10, 100';
+    const full_query = sql.full.compose_select<ATable>({
+      projection,
+      table,
+      where,
+      order,
+      limit
+    });
+    assert.strictEqual(final_query, full_query);
+  });
+  it('should generate the same query SELECT', () => {
+    let final_query = '';
+    final_query += 'SELECT foo, boo FROM `a-table` WHERE';
+    final_query += ' (`foo` > 2 AND `foo` <= 100 AND `boo` = "123")';
+    final_query += ' ORDER BY `foo` DESC';
+    final_query += ' LIMIT 10, 100';
+    const projection = ['foo', 'boo'];
+    const table = 'a-table';
+    const where = {$and: [{foo: {$gt: 2}}, {foo: {$lte: 100}}, {boo: '123'}]};
+    const order = {foo: 'desc'} as const;
+    const limit = '10, 100';
+    const full_query = sql.full.compose_select<ATable>({
+      projection,
+      table,
+      where,
+      order,
+      limit
+    });
+    assert.strictEqual(final_query, full_query);
+  });
+  it('should generate the same query SELECT', () => {
+    let final_query = '';
+    final_query += 'SELECT foo, boo FROM `a-table` WHERE';
+    final_query += ' (`boo` = "a" OR `boo` IN [1,2,3])';
+    final_query += ' ORDER BY `foo` DESC';
+    final_query += ' LIMIT 10, 100';
+    const projection = ['foo', 'boo'];
+    const table = 'a-table';
+    const where = {$or: [{boo: 'a'}, {boo: {$in: ['1','2','3']}}]};
+    const order = {foo: 'desc'} as const;
+    const limit = '10, 100';
+    const full_query = sql.full.compose_select<ATable>({
+      projection,
+      table,
+      where,
+      order,
+      limit
+    });
+    assert.strictEqual(final_query, full_query);
+  });
+  it('should generate the same query SELECT', () => {
+    let final_query = '';
+    final_query += 'SELECT * FROM `a-table` WHERE';
+    final_query += ' (';
+    final_query += '`boo` = "a" OR `boo` IN [1,2,3]';
+    final_query += ' OR';
+    final_query += ' (`foo` = 2 AND `foo` = 1)'
+    final_query += ')';
+    const table = 'a-table';
+    const where = {
+      $or: [
+        {boo: 'a'},
+        {boo: {$in: ['1','2','3']}},
+        {
+          $and: [
+            {foo: 2},{foo: 1}
+          ]
+        },
+      ]
+    };
+    const full_query = sql.full.compose_select<ATable>({
+      table,
+      where,
+    });
+    assert.strictEqual(final_query, full_query);
+  });
+});
+
+describe('Testing SQL full query UPDATE', () => {
+  it('should generate the same query UPDATE', () => {
+    const table = 'uranio-table';
+    const update = {
+      boo: '1',
+      foo: 2
+    };
+    const where = {
+      $or: [
+        {boo: 'a'},
+        {boo: {$in: ['1','2','3']}},
+        {
+          $and: [
+            {foo: 2},{foo: 1}
+          ]
+        },
+      ]
+    };
+    const full_query = sql.full.compose_update<ATable>({
+      table,
+      update,
+      where
+    });
+    let final_query = '';
+    final_query += 'UPDATE `uranio-table` SET';
+    final_query += ' boo = "1", foo = 2 WHERE';
+    final_query += ' (';
+    final_query += '`boo` = "a" OR `boo` IN [1,2,3]';
+    final_query += ' OR ';
+    final_query += '(`foo` = 2 AND `foo` = 1)';
+    final_query += ')';
+    assert.strictEqual(final_query, full_query);
+  });
+});
+
+describe('Testing SQL full query DELETE', () => {
+  it('should generate the same query DELETE', () => {
+    const table = 'uranio-table';
+    const where = {
+      $or: [
+        {boo: 'a'},
+        {boo: {$in: ['1','2','3']}},
+        {
+          $and: [
+            {foo: 2},{foo: 1}
+          ]
+        },
+      ]
+    };
+    const full_query = sql.full.compose_delete<ATable>({
+      table,
+      where
+    });
+    let final_query = '';
+    final_query += 'DELETE FROM `uranio-table`';
+    final_query += ' WHERE';
+    final_query += ' (';
+    final_query += '`boo` = "a" OR `boo` IN [1,2,3]';
+    final_query += ' OR ';
+    final_query += '(`foo` = 2 AND `foo` = 1)';
+    final_query += ')';
+    assert.strictEqual(final_query, full_query);
+  });
+});
+
+describe('Testing SQL full query INSERT', () => {
+  it('should generate the same query INSERT', () => {
+    const table = 'uranio-table';
+    const columns = ['boo', 'foo'] as (keyof ATable)[];
+    const records = [
+      {boo: 'u', foo: 9},
+      {boo: 'w', foo: 19},
+    ];
+    const full_query = sql.full.compose_insert<ATable>({
+      table,
+      columns,
+      records
+    });
+    let final_query = '';
+    final_query += 'INSERT INTO `uranio-table` (`boo`, `foo`)';
+    final_query += ' VALUES';
+    final_query += ' ("u", 9), ("w", 19)';
+    assert.strictEqual(final_query, full_query);
+  });
+});

package/.uranio/tests/sql.param.test.ts

@@ -0,0 +1,108 @@
+import {describe, it} from 'node:test';
+import assert from 'node:assert';
+
+import * as sql from '../src/sql/index';
+
+type ATable = {
+  _id: string
+  foo: number
+  boo: string
+}
+
+describe('Testing SQL param query SELECT', () => {
+  it('should generate the same query SELECT', () => {
+    const projection = ['foo', 'boo'];
+    const table = 'a-table';
+    const where = {foo: {$gt: 2, $lte: 100}, boo: 'str'};
+    const order = {foo: 'desc'} as const;
+    const limit = '10, 100';
+    const {query} = sql.param.compose_select<ATable>({
+      projection,
+      table,
+      where,
+      order,
+      limit
+    });
+    let final_query = '';
+    final_query += 'SELECT foo, boo FROM `a-table` WHERE';
+    final_query += ' `foo` > :x0002 AND `foo` <= :x0003 AND `boo` = :x0004';
+    final_query += ' ORDER BY `foo` DESC LIMIT 10, :x0003';
+    assert.strictEqual(query, final_query);
+  });
+});
+
+describe('Testing SQL param query UPDATE', () => {
+  it('should generate the same query UPDATE', () => {
+    const table = 'uranio-table';
+    const update = {
+      boo: '1',
+      foo: 2
+    };
+    const where = {
+      $or: [
+        {boo: 'a'},
+        {boo: {$in: ['1','2','3']}},
+        {
+          $and: [
+            {foo: 2},{foo: 1}
+          ]
+        },
+      ]
+    };
+    const {query} = sql.param.compose_update<ATable>({
+      table,
+      update,
+      where
+    });
+    let final_query = '';
+    final_query += 'UPDATE `uranio-table` SET boo = :x0016, foo = :x0014 WHERE';
+    final_query += ' (`boo` = :x0012 OR `boo` IN :x0013 OR';
+    final_query += ' (`foo` = :x0014 AND `foo` = :x0015))';
+    assert.strictEqual(query, final_query);
+  });
+});
+
+describe('Testing SQL param query DELETE', () => {
+  it('should generate the same query DELETE', () => {
+    const table = 'uranio-table';
+    const where = {
+      $or: [
+        {boo: 'a'},
+        {boo: {$in: ['1','2','3']}},
+        {
+          $and: [
+            {foo: 2},{foo: 1}
+          ]
+        },
+      ]
+    };
+    const {query} = sql.param.compose_delete<ATable>({
+      table,
+      where
+    });
+    let final_query = '';
+    final_query += 'DELETE FROM `uranio-table` WHERE';
+    final_query += ' (`boo` = :x0025 OR `boo` IN :x0026 OR';
+    final_query += ' (`foo` = :x0027 AND `foo` = :x0028))';
+    assert.strictEqual(query, final_query);
+  });
+});
+
+describe('Testing SQL param query INSERT', () => {
+  it('should generate the same query INSERT', () => {
+    const table = 'uranio-table';
+    const columns = ['boo', 'foo'] as (keyof ATable)[];
+    const records = [
+      {boo: 'u', foo: 9},
+      {boo: 'w', foo: 19},
+    ];
+    const {query} = sql.param.compose_insert<ATable>({
+      table,
+      columns,
+      records
+    });
+    let final_query = '';
+    final_query += 'INSERT INTO `uranio-table` (`boo`, `foo`) VALUES ?';
+    assert.strictEqual(query, final_query);
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uranio",
-  "version": "0.1.19",
+  "version": "0.1.21",
   "description": "Uranio is a type-safe ODM for MongoDB",
   "main": "dist/index.js",
   "repository": {
@@ -56,6 +56,7 @@
     "app-root-path": "^3.1.0",
     "i0n": "^0.8.1",
     "mongodb": "^6.3.0",
+    "mysql2": "^3.7.0",
     "plutonio": "^0.5.1",
     "r4y": "^0.6.0"
   }

package/src/cli/generate/index.ts

@@ -2,6 +2,16 @@
  *
  * Generate index module
  *
+ * `generate` command do the following:
+ *
+ * - copy the directory `.uranio` from its root directory into the
+ *   `node_modules` of the project where the command is run.
+ *
+ * - After parsing the types with `plutonio` it updates the copied typescript
+ *   files.
+ *
+ * - It then build the updated `.uranio` files as a typescript project.
+ *
  * @packageDocumentation
  */
 
@@ -65,7 +75,7 @@ async function _update_dot_uranio(params: GenerateParams) {
   log.spinner.text(`Updating dot uranio files...`);
   const uranio_extended_interfaces = _get_uranio_extended_interfaces(params);
   const text = _generate_uranio_client_module_text(uranio_extended_interfaces);
-  const uranio_client_path = `${params.root}/node_modules/.uranio/src/uranio-client.ts`;
+  const uranio_client_path = `${params.root}/node_modules/.uranio/src/client.ts`;
   fs.writeFileSync(uranio_client_path, text);
   log.debug(`Updated dot uranio files`);
 }
@@ -116,6 +126,7 @@ function _get_uranio_extended_interfaces(params: GenerateParams) {
     }
   }
   // log.trace(uranio_extended_interfaces);
+  _debug_interfaces(uranio_extended_interfaces);
   return uranio_extended_interfaces;
 }
 
@@ -129,16 +140,40 @@ function _generate_uranio_client_module_text(interfaces: plutonio.Interfaces) {
   text += ` *\n`;
   text += ` */\n`;
   text += `\n`;
-  text += `import {Client, ClientParams} from './client';\n`;
-  text += `import {AtomClient} from './atom';\n`;
-  text += `import {atom} from './types';\n`;
+  text += `import {MongoDBClient, MongoDBClientParams} from './client/mongodb';`;
+  text += `import {MySQLClient, MySQLClientParams} from './client/mysql';`;
+  text += `\n`;
+  text += `import {MongoDBAtomClient} from './atom/mongodb';`;
+  text += `import {MySQLAtomClient} from './atom/mysql';`;
+  text += `\n`;
+  text += `import * as t from './types/index';`;
   text += `\n`;
   text += _generate_interface_definitions(interfaces);
-  text += `export class UranioClient extends Client{\n`;
-  text += _generate_client_class_attributes(interfaces);
-  text += `  constructor(params: ClientParams) {\n`;
+  text += _generate_mongodb_client(interfaces);
+  text += _generate_mysql_client(interfaces);
+  text += `\n`;
+  return text;
+}
+
+function _generate_mongodb_client(interfaces: plutonio.Interfaces){
+  let text = '';
+  text += `export class UranioMongoDBClient extends MongoDBClient{\n`;
+  text += _generate_mongodb_client_attributes(interfaces);
+  text += `  constructor(params: MongoDBClientParams) {\n`;
+  text += `    super(params);\n`;
+  text += _generate_mongodb_client_initialization(interfaces);
+  text += `  }\n`;
+  text += `}\n`;
+  return text;
+}
+
+function _generate_mysql_client(interfaces: plutonio.Interfaces){
+  let text = '';
+  text += `export class UranioMySQLClient extends MySQLClient{\n`;
+  text += _generate_mysql_client_attributes(interfaces);
+  text += `  constructor(params: MySQLClientParams) {\n`;
   text += `    super(params);\n`;
-  text += _generate_client_initialization(interfaces);
+  text += _generate_mysql_client_initialization(interfaces);
   text += `  }\n`;
   text += `}\n`;
   return text;
@@ -162,20 +197,38 @@ function _generate_interface_definitions(interfaces: plutonio.Interfaces) {
   return text;
 }
 
-function _generate_client_class_attributes(interfaces: plutonio.Interfaces) {
+function _generate_mongodb_client_attributes(interfaces: plutonio.Interfaces) {
   let text = '';
   for (const [name, _inter] of Object.entries(interfaces)) {
     let lc = _first_letter_lowercase(name);
-    text += `  public ${lc}: AtomClient<${name}>;\n`;
+    text += `  public ${lc}: MongoDBAtomClient<${name}>;\n`;
   }
   return text;
 }
 
-function _generate_client_initialization(interfaces: plutonio.Interfaces) {
+function _generate_mongodb_client_initialization(interfaces: plutonio.Interfaces) {
   let text = '';
   for (const [name, _inter] of Object.entries(interfaces)) {
     let lc = _first_letter_lowercase(name);
-    text += `    this.${lc} = new AtomClient<${name}>(this.db, '${lc}');\n`;
+    text += `    this.${lc} = new MongoDBAtomClient<${name}>(this.db, '${lc}');\n`;
+  }
+  return text;
+}
+
+function _generate_mysql_client_attributes(interfaces: plutonio.Interfaces) {
+  let text = '';
+  for (const [name, _inter] of Object.entries(interfaces)) {
+    let lc = _first_letter_lowercase(name);
+    text += `  public ${lc}: MySQLAtomClient<${name}>;\n`;
+  }
+  return text;
+}
+
+function _generate_mysql_client_initialization(interfaces: plutonio.Interfaces) {
+  let text = '';
+  for (const [name, _inter] of Object.entries(interfaces)) {
+    let lc = _first_letter_lowercase(name);
+    text += `    this.${lc} = new MySQLAtomClient<${name}>(this.db, '${lc}');\n`;
   }
   return text;
 }
@@ -186,3 +239,9 @@ function _first_letter_lowercase(str: string): string {
   }
   return str.charAt(0).toLowerCase() + str.slice(1);
 }
+
+function _debug_interfaces(uranio_extended_interfaces: plutonio.Interfaces){
+  for(let [key, _value] of Object.entries(uranio_extended_interfaces)){
+    log.info(`Processing Interface: ${key}`);
+  }
+}

package/.uranio/src/types.ts

@@ -1,25 +0,0 @@
-/**
- *
- * Types module
- *
- * @packageDocumentation
- *
- */
-
-export * from './query';
-
-export interface atom {
-  _id: string
-}
-
-// export type primary<T> = T & {__uranio: 'primary'};
-
-export type unique<T> = T & {__uranio: 'unique'};
-
-// type PrimaryAttribute<A extends atom> = {
-//   [K in keyof A]: A[K] extends {__uranio: 'primary'} ? K : never;
-// }[keyof A];
-
-// export type Shape<A extends atom> = Omit<A, PrimaryAttribute<A>>;
-
-export type Shape<A extends atom> = Omit<A, '_id'>;

package/.uranio/src/uranio-client.ts

@@ -1,25 +0,0 @@
-/**
- *
- * UranioClient module
- *
- * @packageDocumentation
- *
- */
-
-import {Client, ClientParams} from './client';
-// import {AtomClient} from './atom';
-// import {atom} from './types';
-
-// interface Product extends atom {
-//   title: string;
-//   price: number;
-// }
-
-export class UranioClient extends Client{
-  // public product: AtomClient<Product>;
-  constructor(params: ClientParams) {
-    super(params);
-    // this.product = new AtomClient<Product>(this.db, 'product');
-  }
-}
-