uranio 0.1.3 → 0.1.5

package/dot/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "client",
+  "version": "1.0.0",
+  "main": "dist/index.js",
+  "license": "MIT",
+  "scripts": {
+    "build": "yarn tsc -b",
+    "dev": "yarn tsc -w"
+  },
+  "devDependencies": {
+    "@types/node": "^20.9.0",
+    "@typescript-eslint/eslint-plugin": "^5.59.1",
+    "@typescript-eslint/parser": "^5.59.1",
+    "eslint": "^8.39.0",
+    "eslint-config-prettier": "^8.8.0",
+    "eslint-plugin-import": "^2.27.5",
+    "eslint-plugin-jest": "^27.2.1",
+    "eslint-plugin-json": "^3.1.0",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-promise": "^6.1.1",
+    "husky": "^8.0.3",
+    "lint-staged": "^13.2.1",
+    "prettier": "2.8.7",
+    "tsc-watch": "^6.0.0",
+    "typescript": "^5.2.2"
+  },
+  "dependencies": {
+    "i0n": "^0.7.3",
+    "mongodb": "^6.2.0"
+  }
+}

package/dot/src/atom.ts

@@ -0,0 +1,132 @@
+/**
+ *
+ * Atom client module
+ *
+ */
+
+import mongodb from 'mongodb';
+
+import {Atom, Query, Shape} from './types';
+
+export class AtomClient<S extends Atom> {
+
+  public collection: mongodb.Collection<S>;
+
+  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>);
+    if (!item) {
+      return null;
+    }
+    item = _string_id(item) as S;
+    return item;
+  }
+
+  public async get_items(query: Query<S>): Promise<S[]> {
+    query = _instance_object_id(query);
+    let items = await this.collection
+      .find<S>(query as mongodb.Filter<S>)
+      .toArray();
+    for (let item of items) {
+      item = _string_id(item) as S;
+    }
+    return items;
+  }
+
+  public async put_item(shape: Shape<S>): Promise<mongodb.InsertOneResult> {
+    shape = _remove_id(shape as Partial<S>);
+    const respone_insert = await this.collection.insertOne(
+      shape as mongodb.OptionalUnlessRequiredId<S>
+    );
+    return respone_insert;
+  }
+
+  public async put_items(atoms: Shape<S>[]): Promise<mongodb.InsertManyResult> {
+    const atoms_no_ids: mongodb.OptionalUnlessRequiredId<S>[] = [];
+    for (const atom of atoms) {
+      const atom_no_id = _remove_id(
+        atom as Partial<S>
+      ) as mongodb.OptionalUnlessRequiredId<S>;
+      atoms_no_ids.push(atom_no_id);
+    }
+    let items = await this.collection.insertMany(atoms_no_ids);
+    return items;
+  }
+
+  public async update_item(
+    query: Query<S>,
+    atom: Partial<S>
+  ): Promise<mongodb.UpdateResult> {
+    query = _instance_object_id(query);
+    atom = _remove_id(atom) as Partial<S>;
+    const response_update = await this.collection.updateOne(
+      query as mongodb.Filter<S>,
+      {$set: atom}
+    );
+    return response_update;
+  }
+
+  public async update_items(
+    query: Query<S>,
+    atom: Partial<S>
+  ): Promise<mongodb.UpdateResult> {
+    query = _instance_object_id(query);
+    atom = _remove_id(atom) as Partial<S>;
+    const response_update = await this.collection.updateMany(
+      query as mongodb.Filter<S>,
+      {$set: atom}
+    );
+    return response_update;
+  }
+
+  public async delete_item(query: Query<S>): Promise<mongodb.DeleteResult> {
+    query = _instance_object_id(query);
+    const response_delete = await this.collection.deleteOne(
+      query as mongodb.Filter<S>
+    );
+    return response_delete;
+  }
+
+  public async delete_items(query: Query<S>): Promise<mongodb.DeleteResult> {
+    query = _instance_object_id(query);
+    const response_delete = await this.collection.deleteMany(
+      query as mongodb.Filter<S>
+    );
+    return response_delete;
+  }
+}
+
+type StringId<T extends unknown> = T extends {_id: any}
+  ? Omit<T, '_id'> & {_id: string}
+  : T;
+
+function _string_id<T extends unknown>(item: T): StringId<T> {
+  if (item && typeof item === 'object' && '_id' in item) {
+    if (item._id?.toString) {
+      item._id = item._id.toString();
+    }
+    item._id = String(item._id);
+  }
+  return item as StringId<T>;
+}
+
+function _remove_id<A extends Atom>(atom: Partial<A>): Shape<A> {
+  delete (atom as any)._id;
+  return atom as Shape<A>;
+}
+
+function _instance_object_id<A extends Atom>(query: Query<A>): Query<A> {
+  for (let [key, value] of Object.entries(query)) {
+    if (key === '_id' && typeof value === 'string') {
+      query['_id'] = new mongodb.ObjectId(value) as any;
+    }
+    if (value && typeof value === 'object') {
+      value = _instance_object_id(value);
+    }
+  }
+  return query;
+}

package/dot/src/client.ts

@@ -0,0 +1,42 @@
+/**
+ *
+ * Client module
+ *
+ * @packageDocumentation
+ *
+ */
+
+import mongodb, {MongoClient, ServerApiVersion} from 'mongodb';
+import {log} from './log/index';
+
+export type ClientParams = {
+  uri: string;
+  db_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.');
+  }
+  public async disconnect() {
+    log.trace('Disconnecting...');
+    await this.client.close();
+    log.trace('Disconnected.');
+  }
+}
+
+

package/dot/src/index.ts

@@ -0,0 +1,14 @@
+/**
+ *
+ * Index module
+ *
+ * @packageDocumentation
+ *
+ */
+
+import * as types from './types';
+export {types};
+
+import {UranioClient} from './uranio-client';
+export default UranioClient;
+

package/dot/src/log/index.ts

@@ -0,0 +1,10 @@
+/**
+ *
+ * Log index module
+ *
+ * @packageDocumentation
+ *
+ */
+
+import ion from 'i0n';
+export const log = ion.create();

package/dot/src/query.ts

@@ -0,0 +1,56 @@
+/**
+ *
+ * Query type module
+ *
+ */
+
+import {Atom} from './types';
+
+export type Query<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>
+  ? T | RegExpOrString<U>
+  : RegExpOrString<T>;
+
+type RegExpOrString<T> = T extends string ? RegExp | T : T;
+
+interface FilterOperators<T> {
+  $eq?: T;
+  $gt?: T;
+  $gte?: T;
+  $in?: ReadonlyArray<T>;
+  $lt?: T;
+  $lte?: T;
+  $ne?: T;
+  $nin?: ReadonlyArray<T>;
+  $not?: T extends string ? FilterOperators<T> | RegExp : FilterOperators<T>;
+  $exists?: boolean;
+  $expr?: Record<string, any>;
+  $jsonSchema?: Record<string, any>;
+  $mod?: T extends number ? [number, number] : never;
+  $regex?: T extends string ? RegExp | string : never;
+  $options?: T extends string ? string : never;
+  $maxDistance?: number;
+  $all?: ReadonlyArray<any>;
+  $size?: T extends ReadonlyArray<any> ? number : never;
+  $rand?: Record<string, never>;
+}
+
+interface RootFilterOperators<A extends Atom> {
+  $and?: Query<A>[];
+  $nor?: Query<A>[];
+  $or?: Query<A>[];
+  $text?: {
+    $search: string;
+    $language?: string;
+    $caseSensitive?: boolean;
+    $diacriticSensitive?: boolean;
+  };
+  $where?: string | ((this: A) => boolean);
+  $comment?: string;
+}
+

package/dot/src/types.ts

@@ -0,0 +1,16 @@
+/**
+ *
+ * Types module
+ *
+ * @packageDocumentation
+ *
+ */
+
+import {Query} from './query';
+export {Query};
+
+export interface Atom {
+  _id: string;
+}
+
+export type Shape<A extends Atom> = Omit<A, '_id'>;

package/dot/src/uranio-client.ts

@@ -0,0 +1,25 @@
+/**
+ *
+ * UranioClient module
+ *
+ * @packageDocumentation
+ *
+ */
+
+import {Client, ClientParams} from './client';
+// import {Atom} from './types';
+// import {AtomClient} from './atom';
+
+// 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');
+  }
+}
+

package/dot/tsconfig.json

@@ -0,0 +1,33 @@
+{
+  "compilerOptions": {
+    "alwaysStrict": true,
+    "allowJs": true,
+    "baseUrl": ".",
+    "declaration": true,
+    "esModuleInterop": true,
+    "experimentalDecorators": true,
+    "incremental": false,
+    "lib": ["ESNext", "ESNext.AsyncIterable", "DOM", "ES2021"],
+    "module": "CommonJS",
+    "moduleResolution": "node",
+    "noEmit": false,
+    "noFallthroughCasesInSwitch": true,
+    "noImplicitThis": true,
+    "noImplicitAny": true,
+    "noUncheckedIndexedAccess": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "skipLibCheck": true,
+    "sourceMap": true,
+    "strict": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "strictPropertyInitialization": true,
+    "target": "ES2018",
+    "typeRoots": ["node_modules/@types"]
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules"]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uranio",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Uranio is a type-safe ODM for MongoDB",
   "main": "dist/index.js",
   "repository": {
@@ -38,7 +38,6 @@
     "typescript": "^5.2.2"
   },
   "dependencies": {
-    "husky": "^8.0.3",
     "i0n": "^0.7.3",
     "plutonio": "^0.2.2"
   }

package/scripts/version.sh

@@ -1,12 +1,5 @@
 #!/bin/bash
 
-if [[ `git status --porcelain` ]]; then
-  echo
-  echo "Error: Git working directory is not clean. Please commit your changes or stash them."
-  echo
-  exit 1
-fi;
-
 SEMANTIC_NAME=$1
 
 if [ "$SEMANTIC_NAME" == "" ]; then
@@ -19,7 +12,7 @@ fi
 
 case "$SEMANTIC_NAME" in
   patch)
-    npm version patch --no-git-tag-version
+    yarn version --patch --no-git-tag-version
     break;
     ;;
   minor)
@@ -31,7 +24,7 @@ case "$SEMANTIC_NAME" in
         * ) echo "Please answer [y]es or [n]o.";;
       esac
     done
-    npm version minor --no-git-tag-version
+    yarn version --minor --no-git-tag-version
     break;
     ;;
   major)
@@ -43,7 +36,7 @@ case "$SEMANTIC_NAME" in
         * ) echo "Please answer [y]es or [n]o.";;
       esac
     done
-    npm version major --no-git-tag-version
+    yarn version --major --no-git-tag-version
     break;
     ;;
   *)
@@ -55,7 +48,5 @@ case "$SEMANTIC_NAME" in
     ;;
 esac
 
-git push origin
 VERSION=$(node -p "require('./package.json').version")
-# git push origin v$VERSION
 yarn publish --new-version $VERSION --no-git-tag-version