tweak: Update the way changes and conditions are defined to allow arrays

lib/BSON.ts

@@ -1 +1,22 @@
-export { ObjectID, Binary } from "mongodb";
+export { ObjectID, Binary } from "mongodb";
+import { ObjectID } from "mongodb";
+
+export type BSONType =
+    undefined
+    |null
+    |number
+    |string|symbol
+    |BSONObject
+    |BSONArray
+    |ObjectID
+    |boolean
+    |Date
+    |RegExp;
+
+export interface BSONObject {
+    [property: string]: BSONType;
+}
+
+export interface BSONArray {
+    [property: number]: BSONType;
+}

lib/Changes.ts

@@ -1,9 +1,8 @@
-import {Conditions, UnderlyingBSONType} from "./Conditions";
+import {Conditions} from "./Conditions";
+import {BSONType, BSONArray, BSONObject} from "./BSON";
 
 export interface Changes {
-    $set?: {
-        [property: string]: UnderlyingBSONType;
-    };
+    $set?: BSONObject;
 
     $unset?: {
         [property: string]: boolean;
@@ -19,29 +18,29 @@ export interface Changes {
 
     $addToSet?: {
         [property: string]: {
-            $each: UnderlyingBSONType[];
-        }|any;
+            $each: BSONArray;
+        };
     }
 
     $push?: {
         [property: string]: {
-            $each: UnderlyingBSONType[];
-            $slice?: number;
-            $position?: number; 
-        }|{
-            $each: UnderlyingBSONType[];
+            $each: BSONArray;
             $slice: number;
             $sort: { [property: string]: number; };
             $position?: number; 
-        }|UnderlyingBSONType;
+        }|{
+            $each: BSONArray;
+            $slice?: number;
+            $position?: number; 
+        }|BSONObject|BSONType;
     };
 
     $pull?: {
         [property: string]: Conditions;
     };
 
     $pullAll?: {
-        [property: string]: UnderlyingBSONType[];
+        [property: string]: BSONArray;
     };
 
     $rename?: {

lib/Conditions.ts

@@ -1,25 +1,15 @@
-import {ObjectID} from "mongodb";
-
-export type UnderlyingBSONType = null
-    |number
-    |string|symbol
-    |{[property: string]: UnderlyingBSONType;}
-    //|UnderlyingBSONType[]
-    |ObjectID
-    |boolean
-    |Date
-    |RegExp;
+import {BSONType, BSONArray, ObjectID} from "./BSON";
 
 export interface Conditions {
     [property: string]: {
-        $eq?: UnderlyingBSONType;
-        $ne?: UnderlyingBSONType;
-        $in?: UnderlyingBSONType[];
-        $nin?: UnderlyingBSONType[];
+        $eq?: BSONType;
+        $ne?: BSONType;
+        $in?: BSONArray;
+        $nin?: BSONArray;
         $elemMatch?: Conditions;
-        $gt?: UnderlyingBSONType;
-        $gte?: UnderlyingBSONType;
-        $lt?: UnderlyingBSONType;
-        $lte?: UnderlyingBSONType;
-    }|UnderlyingBSONType;
+        $gt?: BSONType;
+        $gte?: BSONType;
+        $lt?: BSONType;
+        $lte?: BSONType;
+    }|BSONType;
 }

test/Changes.ts

@@ -0,0 +1,47 @@
+import * as Iridium from "../iridium";
+import * as chai from "chai";
+
+interface Document {
+    _id?: string;
+    path: {
+        type: "LineString";
+        coordinates: number[][];
+    };
+}
+
+@Iridium.Collection("test")
+class Instance extends Iridium.Instance<Document, Instance> {
+    @Iridium.ObjectID
+    _id: string;
+
+    @Iridium.Property({
+        type: /^LineString$/,
+        coordinates: [[Number, 2, 2]]
+    })
+    path: {
+        type: "LineString";
+        coordinates: number[][];
+    };
+}
+
+class Core extends Iridium.Core {
+    Model = new Iridium.Model<Document, Instance>(this, Instance);
+}
+
+describe("Changes", () => {
+    let core = new Core("mongodb://localhost/iridium_test");
+
+    describe("should allow you to specify valid operations", () => {
+        it("should allow you to use the $push operator", () => {
+            return core.Model.update({}, {
+                $push: {
+                    "path.coordinates": {
+                        $each: [[1, 2]],
+                        $position: 1,
+                        $sort: { a: 1 }
+                    }
+                }
+            });
+        });
+    });
+});