uranio 0.1.19 → 0.1.21

package/.uranio/src/sql/full_query.ts

@@ -0,0 +1,328 @@
+/**
+ *
+ * JS Object to SQL expanded query converter module
+ *
+ * @packageDocumentation
+ *
+ */
+
+import * as t from '../types/index';
+
+export function compose_select<S extends t.atom>({
+  projection = ['*'],
+  table,
+  where,
+  order,
+  limit,
+}: {
+  projection?: string[];
+  table: string;
+  where?: t.Where<S>;
+  order?: t.OrderBy;
+  limit?: string;
+}) {
+  let query_string = 'SELECT';
+  query_string += _resolve_projection(projection);
+  query_string += ` FROM \`${table}\``;
+  if(where && typeof where === 'object' && Object.entries(where).length > 0){
+    query_string += ` WHERE ` + _resolve_where<S>(where);
+  }
+  query_string += _resolve_order(order);
+  query_string += _resolve_limit(limit);
+  return query_string;
+}
+
+export function compose_update<S extends t.atom>({
+  table,
+  update,
+  where,
+}: {
+  table: string;
+  update: Partial<S>;
+  where?: t.Where<S>;
+}) {
+  let query_string = 'UPDATE';
+  query_string += ` \`${table}\``;
+  query_string += ` SET`;
+  query_string += _resolve_update(update);
+  query_string += ` WHERE ` + _resolve_where<S>(where);
+  return query_string;
+}
+
+export function compose_delete<S extends t.atom>({
+  table,
+  where,
+}: {
+  table: string;
+  where?: t.Where<S>;
+}) {
+  let query_string = 'DELETE';
+  query_string += ` FROM \`${table}\``;
+  query_string += ` WHERE ` + _resolve_where<S>(where);
+  return query_string;
+}
+
+export function compose_insert<S extends t.atom>({
+  table,
+  columns,
+  records,
+}: {
+  table: string;
+  columns: (keyof S)[];
+  records: Partial<S>[];
+}) {
+  let query_string = 'INSERT INTO';
+  query_string += ` \`${table}\``;
+  query_string += _resolve_columns(columns);
+  query_string += _resolve_records(columns, records);
+  return query_string;
+}
+
+function _resolve_where<S extends t.atom>(where?: t.Where<S>): string {
+  if (
+    !where ||
+    typeof where !== 'object' ||
+    Object.entries(where).length === 0
+  ) {
+    return '';
+  }
+  const where_parts: string[] = [];
+  // console.log(`t.Where param: ${JSON.stringify(where)}`);
+  for (const [key, value] of Object.entries(where)) {
+    // console.log(`Key: ${key}, Value: ${JSON.stringify(value)}`);
+    if (t.root_operators.includes(key as t.RootOperator)) {
+      // console.log(`Key is in root operators`);
+      if (!Array.isArray(value)) {
+        throw new Error(
+          `Invalid t.Where. Root operator '${key}' must have an Array as value`
+        );
+      }
+      const queries = value.map((el) => _resolve_where(el));
+      // console.log(`Queries: ${queries}`);
+      switch (key) {
+        case '$and': {
+          const joined_queries = queries.join(' AND ');
+          where_parts.push(`(${joined_queries})`);
+          break;
+        }
+        case '$or': {
+          const joined_queries = queries.join(' OR ');
+          where_parts.push(`(${joined_queries})`);
+          break;
+        }
+        case '$nor': {
+          const joined_queries = queries.join(' NOR ');
+          where_parts.push(`(${joined_queries})`);
+          break;
+        }
+        default: {
+          throw new Error(`Invalid root operator`);
+        }
+      }
+      // console.log(`t.Where parts: ${where_parts}`);
+      const final_where = where_parts.join(` AND `);
+      return final_where;
+    }
+    // if (filter_operators.includes(key as FilterOperator)) {
+    //   throw new Error(
+    //     `Invalid key. Key cannot be equal to an operator. Using '${key}'`
+    //   );
+    // }
+    if(value instanceof RegExp){
+      let query_string = `\`${key}\``;
+      query_string += ` REGEXP ` + _format_value(value);
+      where_parts.push(query_string);
+      continue;
+    }
+    if (value && typeof value === 'object') {
+      // console.log(`Type of value is object --> using filter operator...`);
+      if (Object.entries(value).length === 0) {
+        throw new Error(`Cannot compare to empty object value`);
+      }
+      let query_string = '';
+      query_string += '' + _resolve_filter(key, value as t.Operator);
+      where_parts.push(query_string);
+      continue;
+    }
+    let query_string = `\`${key}\``;
+    query_string += ` = ` + _format_value(value);
+    where_parts.push(query_string);
+  }
+  const final_where = where_parts.map((el) => `${el}`).join(` AND `);
+  return final_where;
+}
+
+function _resolve_columns<S extends t.atom>(columns: (keyof S)[]): string {
+  return ' (' + columns.map((el) => '`' + String(el) + '`').join(', ') + ')';
+}
+
+function _resolve_records<S extends t.atom>(
+  columns: (keyof S)[],
+  records: Partial<S>[]
+): string {
+  const record_strings: string[] = [];
+  for (let record of records) {
+    const record_parts: string[] = [];
+    for (let column of columns) {
+      record_parts.push(_format_value(record[column]));
+    }
+    const joined_record = record_parts.join(', ');
+    record_strings.push(joined_record);
+  }
+  const full_records = record_strings.map((el) => '(' + el + ')').join(', ');
+  return ` VALUES ${full_records}`;
+}
+
+function _resolve_update<S extends t.atom>(update: Partial<S>): string {
+  const update_parts: string[] = [];
+  for (const [key, value] of Object.entries(update)) {
+    update_parts.push(`${key} = ${_format_value(value)}`);
+  }
+  return ' ' + update_parts.join(', ');
+}
+
+function _resolve_order(order?: t.OrderBy): string {
+  if (
+    !order ||
+    typeof order !== 'object' ||
+    Object.entries(order).length === 0
+  ) {
+    return '';
+  }
+  let query_string = '';
+  let order_strings: string[] = [];
+  for (const [column, direction] of Object.entries(order)) {
+    order_strings.push(`\`${column}\` ${direction.toUpperCase()}`);
+  }
+  const final_order = order_strings.join(', ');
+  query_string += ` ORDER BY ${final_order}`;
+  return query_string;
+}
+
+function _resolve_projection(projection: string[]): string {
+  let query_string = '';
+  const projection_string = projection.join(', ');
+  query_string += ` ${projection_string}`;
+  return query_string;
+}
+
+function _resolve_limit(limit?: string): string {
+  if (typeof limit !== 'string' || limit === '') {
+    return '';
+  }
+  return ` LIMIT ${limit}`;
+}
+
+function _resolve_filter(column: string, operator: t.Operator) {
+  let filter_strings: string[] = [];
+  for (let [key, value] of Object.entries(operator)) {
+    switch (key) {
+      case '$eq': {
+        filter_strings.push(`\`${column}\` = ${_format_value(value)}`);
+        break;
+      }
+      case '$gt': {
+        filter_strings.push(`\`${column}\` > ${_format_value(value)}`);
+        break;
+      }
+      case '$gte': {
+        filter_strings.push(`\`${column}\` >= ${_format_value(value)}`);
+        break;
+      }
+      case '$in': {
+        filter_strings.push(`\`${column}\` IN ${_format_value(value)}`);
+        break;
+      }
+      case '$lt': {
+        filter_strings.push(`\`${column}\` < ${_format_value(value)}`);
+        break;
+      }
+      case '$lte': {
+        filter_strings.push(`\`${column}\` <= ${_format_value(value)}`);
+        break;
+      }
+      case '$ne': {
+        filter_strings.push(`\`${column}\` <> ${_format_value(value)}`);
+        break;
+      }
+      case '$nin': {
+        filter_strings.push(`\`${column}\` NOT IN ${_format_value(value)}`);
+        break;
+      }
+      // Recursive
+      case '$not': {
+        filter_strings.push(
+          `\`${column}\` NOT (${_resolve_filter(column, value)})`
+        );
+        break;
+      }
+      case '$exists': {
+        if (value === true) {
+          filter_strings.push(`\`${column}\` IS NOT NULL`);
+        } else {
+          filter_strings.push(`\`${column}\` IS NULL`);
+        }
+        break;
+      }
+      default: {
+        throw new Error(`Invalid filter operator`);
+      }
+    }
+  }
+  const filter_string = filter_strings.join(` AND `);
+  return filter_string;
+}
+
+function _format_value(value: unknown): string {
+  let query_string = '';
+  if (Array.isArray(value)) {
+    return `(${value.toString()})`;
+  }
+  if(value instanceof RegExp){
+    return value.source;
+  }
+  switch (typeof value) {
+    case 'string': {
+      query_string = `"${value.replaceAll('"', '"')}"`;
+      return query_string;
+    }
+    default: {
+      return String(value);
+    }
+  }
+}
+
+// function _is_projection_type(type: unknown): boolean {
+//   if (projection_type.includes(type as ProjectionType)) {
+//     return true;
+//   }
+//   return false;
+// }
+
+// function _is_order_type(type: unknown): boolean {
+//   if (order_type.includes(type as ProjectionType)) {
+//     return true;
+//   }
+//   return false;
+// }
+
+// function _is_limit_type(type: unknown): boolean {
+//   if (limit_type.includes(type as ProjectionType)) {
+//     return true;
+//   }
+//   return false;
+// }
+
+// function _is_from_type(type: unknown): boolean {
+//   if (from_type.includes(type as FromType)) {
+//     return true;
+//   }
+//   return false;
+// }
+
+// function _assert_type(type: unknown): asserts type is SQLType {
+//   if (sql_type.includes(type as SQLType)) {
+//     return;
+//   }
+//   throw new Error(`Invalid SQL type`);
+// }

package/.uranio/src/sql/index.ts

@@ -0,0 +1,13 @@
+/**
+ *
+ * SQL index module
+ *
+ * @packageDocumentation
+ *
+ */
+
+import * as full from './full_query';
+export {full};
+
+import * as param from  './param_query';
+export {param};

package/.uranio/src/sql/param_query.ts

@@ -0,0 +1,245 @@
+/**
+ *
+ * JS Object to SQL parametrized query converter module
+ *
+ * @packageDocumentation
+ *
+ */
+
+// import crypto from 'crypto';
+
+import * as t from '../types/index';
+
+import * as full from './full_query';
+
+export function compose_select<S extends t.atom>({
+  projection = ['*'],
+  table,
+  where,
+  order,
+  limit,
+}: {
+  projection?: string[];
+  table: string;
+  where?: t.Where<S>;
+  order?: t.OrderBy;
+  limit?: string;
+}) {
+  // console.log(projection, table, JSON.stringify(where), order, limit);
+  const full_query = full.compose_select({
+    projection,
+    table,
+    where,
+    order,
+    limit,
+  });
+  const value_map = _generate_value_map_from_query(where);
+  const param_query = _replace_value_with_param(full_query, value_map);
+  const map = _transform_map_to_object(value_map);
+  return {query: param_query, map};
+}
+
+export function compose_update<S extends t.atom>({
+  table,
+  update,
+  where,
+}: {
+  table: string;
+  update: Partial<S>;
+  where?: t.Where<S>;
+}) {
+  const full_query = full.compose_update({
+    table,
+    update,
+    where,
+  });
+  const query_value_map = _generate_value_map_from_query(where);
+  const update_value_map = _generate_value_map_from_update(update);
+  for(const [k, v] of update_value_map){
+    query_value_map.set(k, v);
+  }
+  const param_query = _replace_value_with_param(full_query, query_value_map);
+  const map = _transform_map_to_object(query_value_map);
+  return {query: param_query, map};
+}
+
+export function compose_delete<S extends t.atom>({
+  table,
+  where,
+}: {
+  table: string;
+  where?: t.Where<S>;
+}) {
+  const full_query = full.compose_delete({
+    table,
+    where,
+  });
+  const query_value_map = _generate_value_map_from_query(where);
+  const param_query = _replace_value_with_param(full_query, query_value_map);
+  const map = _transform_map_to_object(query_value_map);
+  return {query: param_query, map};
+}
+
+export function compose_insert<S extends t.atom>({
+  table,
+  columns,
+  records,
+}: {
+  table: string;
+  columns: (keyof S)[];
+  records: Partial<S>[];
+}) {
+  const full_query = full.compose_insert({
+    table,
+    columns,
+    records
+  });
+  const splitted_query = full_query.split(' VALUES ');
+  const pre_query = splitted_query[0];
+  const param_query = `${pre_query} VALUES ?`;
+  return {query: param_query, query_records: records};
+}
+
+let id_count = 0;
+function _generate_unique_consecutive_id():string{
+  const id = `x${String(id_count).padStart(4,'0')}`;
+  id_count++;
+  return id;
+}
+
+// function _generate_unique_id(): string {
+//   const now = Date.now();
+//   const hash = crypto.createHash('sha256');
+//   hash.update(now.toString());
+//   const digested = hash.digest('hex');
+//   return 'x' + digested.substring(0, 3) + _generate_random_string(4);
+// }
+
+function _generate_value_map_from_update<S extends t.atom>(
+  update: Partial<S>
+): Map<string, any> {
+  const value_map = new Map<string, any>();
+  for (const [_key, value] of Object.entries(update)) {
+    const id = _generate_unique_consecutive_id();
+    value_map.set(id, value);
+  }
+  return value_map;
+}
+
+function _generate_value_map_from_query<S extends t.atom>(
+  where?: t.Where<S>
+): Map<string, any> {
+  const value_map = new Map<string, any>();
+  if (!where) {
+    return value_map;
+  }
+  for (const [key, value] of Object.entries(where)) {
+    // key is a root operator: $and, $or, ...
+    if (t.root_operators.includes(key as t.RootOperator)) {
+      // console.log(`Key is in Root Operator: [${key}]`);
+      if (!Array.isArray(value)) {
+        throw new Error(
+          `Invalid t.Where. Root operator '${key}' must have an Array as value`
+        );
+      }
+      const sub_maps = value.map((el) => _generate_value_map_from_query(el));
+      for (const sub_map of sub_maps) {
+        for (const [_k, v] of sub_map) {
+          const id = _generate_unique_consecutive_id();
+          value_map.set(id, v);
+        }
+      }
+      continue;
+    }
+    // value is a RegExp
+    if(value instanceof RegExp){
+      const id = _generate_unique_consecutive_id();
+      value_map.set(id, value);
+      continue;
+    }
+    // value is an object therefor is a filter: {$gt: 2, $lt: 20}
+    if (value && typeof value === 'object') {
+      if (Object.entries(value).length === 0) {
+        throw new Error(`Cannot compare to empty object value`);
+      }
+      const filter_map = _generate_map_from_filter(
+        // key,
+        value as Record<t.FilterOperator, string>
+      );
+      for (const [_k, v] of filter_map) {
+        const id = _generate_unique_consecutive_id();
+        value_map.set(id, v);
+      }
+      continue;
+    }
+    // key value are a simple equality: {foo: 123}
+    const id = _generate_unique_consecutive_id();
+    value_map.set(id, value);
+  }
+  return value_map;
+}
+
+function _generate_map_from_filter(
+  // key: string,
+  filter: Record<t.FilterOperator, string>
+): Map<string, any> {
+  const filter_map = new Map<string, any>();
+  for (const [_operator, v] of Object.entries(filter)) {
+    const id = _generate_unique_consecutive_id();
+    filter_map.set(id, v);
+  }
+  return filter_map;
+}
+
+function _replace_value_with_param(
+  full_query: string,
+  value_map: Map<string, any>
+): string {
+  let final_query = full_query;
+  for (const [k, v] of value_map) {
+    if (Array.isArray(v)) {
+      for(const array_value of v){
+        const map = new Map();
+        map.set('a', array_value);
+        final_query = _replace_value_with_param(final_query, map);
+      }
+      continue;
+    }
+    if(v instanceof RegExp){
+      final_query = final_query.replaceAll(` ${v.source}`, ` :${k}`);
+    }
+    switch (typeof v) {
+      case 'string': {
+        final_query = final_query.replaceAll(`"${v}"`, `:${k}`);
+        break;
+      }
+      default: {
+        final_query = final_query.replaceAll(` ${v}`, ` :${k}`);
+      }
+    }
+  }
+  return final_query;
+}
+
+function _transform_map_to_object(map: Map<string, any>): Record<string, any>{
+  const object_map = Object.fromEntries(map);
+  for(const [k,v] of Object.entries(object_map)){
+    if(v instanceof RegExp){
+      object_map[k] = v.source;
+    }
+  }
+  return object_map;
+}
+
+// function _generate_random_string(length = 7): string {
+//   const characters =
+//     'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+//   let result = '';
+
+//   for (let i = 0; i < length; i++) {
+//     const randomIndex = Math.floor(Math.random() * characters.length);
+//     result += characters.charAt(randomIndex);
+//   }
+
+//   return result;
+// }

package/.uranio/src/types/atom.ts

@@ -0,0 +1,28 @@
+/**
+ *
+ * Atom client interface module
+ *
+ * @packageDocumentation
+ *
+ */
+
+// import {atom, Where, Shape, OrderBy} from './index';
+
+// export interface AtomClient<S extends atom> {
+//   get_atom(where: Where<S>): Promise<S | null>;
+//   get_atoms({
+//     where,
+//     order,
+//     limit
+//   }:{
+//     where: Where<S>,
+//     order?: OrderBy,
+//     limit?: string
+//   }): Promise<S[]>;
+//   put_atom(shape: Shape<S>): Promise<any>;
+//   put_atoms(atoms: Shape<S>[]): Promise<any>;
+//   update_atom(where: Where<S>, atom: Partial<S>): Promise<any>;
+//   update_atoms(where: Where<S>, atom: Partial<S>): Promise<any>;
+//   delete_atom(where: Where<S>): Promise<any>;
+//   delete_atoms(where: Where<S>): Promise<any>;
+// }

package/.uranio/src/types/index.ts

@@ -0,0 +1,33 @@
+/**
+ *
+ * Types module
+ *
+ * @packageDocumentation
+ *
+ */
+
+export * from './where';
+
+// export * from './atom';
+
+export * from './sql';
+
+export interface atom {}
+
+export interface mysql_atom extends atom {}
+
+export interface mongodb_atom extends atom {
+  _id: primary<string>;
+}
+
+export type unique<T> = T & {__uranio: 'unique'};
+
+// export type Shape<A extends atom> = Omit<A, '_id'>;
+
+export type primary<T> = T & {__uranio: 'primary'};
+
+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>>;

package/.uranio/src/types/sql.ts

@@ -0,0 +1,34 @@
+/**
+ *
+ * SQL type module
+ *
+ * @packageDocumentation
+ */
+
+export const root_operators = ['$and', '$nor', '$or'] as const;
+
+export const filter_operators = [
+  '$eq',
+  '$gt',
+  '$gte',
+  '$in',
+  '$lt',
+  '$lte',
+  '$ne',
+  '$nin',
+  '$not',
+  '$exists',
+] as const;
+
+export type FilterOperator = (typeof filter_operators)[number];
+
+export type RootOperator = (typeof root_operators)[number];
+
+export type Operator = {
+  [k in FilterOperator]: any;
+};
+
+export type OrderBy = {
+  [k: string]: 'asc' | 'desc';
+};
+