iodm 0.0.1 → 0.0.3

package/dist/index.es.js

@@ -1,14 +1,1211 @@
-class r {
+const D = (s) => typeof s == "function", O = (s) => s == null, P = (s) => s?.constructor ? s.constructor.toString().includes("RegExp()") : !1, C = [
+  "$eq",
+  "$nq",
+  "$gt",
+  "$gte",
+  "$lt",
+  "$lte",
+  "$not",
+  "$regex"
+], j = (s) => typeof s != "object" || !s ? !1 : C.some((t) => t in s), q = (s, t, e) => !("$eq" in t && t.$eq !== e[s] || "$nq" in t && t.$nq === e[s] || !O(t.$gt) && !(t.$gt < e[s]) || !O(t.$gte) && !(t.$gte <= e[s]) || !O(t.$lt) && !(t.$lt > e[s]) || !O(t.$lte) && !(t.$lte >= e[s]) || !O(t.$not) && q(s, t.$not, e) || !O(t.$regex) && !t.$regex.test(e[s])), b = (s, t) => {
+  if (typeof t != "object" || !t) return !0;
+  const e = Object.keys(s).filter((r) => r != "$key");
+  for (const r of e) {
+    const n = s[r];
+    if (r === "$and" && s.$and) {
+      if (!s.$and.every((o) => b(o, t)))
+        return !1;
+    } else if (r === "$or" && s.$or) {
+      if (!s.$or.some((o) => b(o, t)))
+        return !1;
+    } else if (j(n)) {
+      if (!q(r, n, t)) return !1;
+    } else if (P(s[r])) {
+      if (!s[r].test(t[r])) return !1;
+    } else if (s[r] !== t[r]) return !1;
+  }
+  return !0;
+}, E = (s, t) => {
+  if (typeof s != "object" || !s) return s;
+  if (t.$set)
+    for (const e in t.$set)
+      s[e] = t.$set[e];
+  if (t.$unset)
+    for (const e in t.$unset)
+      delete s[e];
+  if (t.$push)
+    for (const e in t.$push)
+      Array.isArray(s[e]) && s[e].push(t.$push[e]);
+  if (t.$pop)
+    for (const e in t.$pop)
+      Array.isArray(s[e]) && (t.$pop[e] == 1 ? s[e].pop() : s[e].shift());
+  return s;
+};
+class M {
+  async openCursor(t, e) {
+    const { storeName: r, transaction: n, throwOnError: o = !0 } = e;
+    return {
+      async *[Symbol.asyncIterator]() {
+        const d = n.objectStore(r).openCursor(t.$key), c = () => new Promise((i, a) => {
+          d.onsuccess = function() {
+            i(this.result);
+          }, d.onerror = function(h) {
+            if (o)
+              return a(h);
+            h.preventDefault(), i(null);
+          };
+        });
+        let u = c();
+        try {
+          for (; ; ) {
+            const i = await u;
+            if (i && i.value)
+              u = c(), i.continue(), b(t, i.value) && (yield i.value);
+            else
+              break;
+          }
+        } catch (i) {
+          if (o)
+            throw i;
+          return { done: !0 };
+        }
+      }
+    };
+  }
+  async find(t, e) {
+    return new Promise((r, n) => {
+      const { storeName: o, transaction: d, Constructor: c } = e, u = [], i = d.objectStore(o).openCursor(t.$key);
+      i.onsuccess = async function() {
+        const a = this.result;
+        if (!a || !a.value) {
+          r(u);
+          return;
+        }
+        if (b(t, a.value)) {
+          const h = a.value && c ? await c.preProcess(a.value, e) : a.value;
+          u.push(h && c ? new c(h) : h);
+        }
+        a.continue();
+      }, i.onerror = (a) => {
+        n(a);
+      };
+    });
+  }
+  async findById(t, e) {
+    return new Promise((r, n) => {
+      const { storeName: o, transaction: d, Constructor: c } = e, u = d.objectStore(o).get(t);
+      u.onsuccess = async (i) => {
+        let a = null;
+        if (i.target && "result" in i.target) {
+          const h = i.target.result && c ? await c.preProcess(i.target.result, e) : i.target.result;
+          a = h && c ? new c(h) : h;
+        }
+        r(a);
+      }, u.onerror = (i) => {
+        n(i);
+      };
+    });
+  }
+  async insertMany(t, e) {
+    const { storeName: r, transaction: n, throwOnError: o } = e, d = n.objectStore(r), c = {
+      result: []
+    };
+    for (let u = 0; u < t.length; ++u) {
+      const i = await new Promise(
+        (a, h) => {
+          const p = d.add(t[u]);
+          p.onsuccess = (l) => {
+            a({ status: "success", event: l });
+          }, p.onerror = (l) => {
+            o ? h(l) : (l.preventDefault(), a({ status: "error", event: l }));
+          };
+        }
+      );
+      c.result.push(i);
+    }
+    return c;
+  }
+  async insertOne(t, e) {
+    return { result: (await this.insertMany(
+      [t],
+      e
+    )).result[0] };
+  }
+  async replaceOne(t, e) {
+    const { storeName: r, transaction: n } = e;
+    return new Promise((o, d) => {
+      let c = e.objectStore;
+      c || (c = n.objectStore(r));
+      const u = c.put(t);
+      u.onsuccess = (i) => {
+        let a;
+        i.target && "result" in i.target && (a = i.target.result), o(a);
+      }, u.onerror = (i) => {
+        d(i);
+      };
+    });
+  }
+  async updateMany(t, e, r) {
+    const { storeName: n, transaction: o, updateLimit: d, throwOnError: c } = r, u = {
+      modifiedCount: 0,
+      matchedCount: 0
+    };
+    return new Promise((i, a) => {
+      const h = o.objectStore(n).openCursor(t.$key);
+      h.onsuccess = (p) => {
+        if (!p.target || !("result" in p.target) || !p.target.result) {
+          i(u);
+          return;
+        }
+        const l = p.target.result;
+        if (!b(t, l.value)) {
+          l.continue();
+          return;
+        }
+        ++u.matchedCount;
+        try {
+          const f = D(e) ? e(l.value) : E(l.value, e), N = l.update(f);
+          N.onsuccess = () => {
+            ++u.modifiedCount, d !== u.modifiedCount ? l.continue() : i(u);
+          }, N.onerror = (v) => {
+            c ? a(v) : (v.preventDefault(), l.continue());
+          };
+        } catch (f) {
+          c ? (o.abort(), a(f)) : l.continue();
+        }
+      }, h.onerror = (p) => {
+        if (c)
+          return a(p);
+        p.preventDefault(), i(u);
+      };
+    });
+  }
+  async updateOne(t, e, r) {
+    return this.updateMany(t, e, {
+      ...r,
+      updateLimit: 1
+    });
+  }
+  async deleteMany(t, e) {
+    const { storeName: r, transaction: n, deleteLimit: o, throwOnError: d } = e, c = {
+      deletedCount: 0,
+      matchedCount: 0
+    };
+    return new Promise((u, i) => {
+      const a = n.objectStore(r).openCursor(t.$key);
+      a.onsuccess = (h) => {
+        if (!h.target || !("result" in h.target) || !h.target.result) {
+          u(c);
+          return;
+        }
+        const p = h.target.result;
+        if (!b(t, p.value)) {
+          p.continue();
+          return;
+        }
+        ++c.matchedCount;
+        try {
+          const l = p.delete();
+          l.onsuccess = () => {
+            ++c.deletedCount, o !== c.deletedCount ? p.continue() : u(c);
+          }, l.onerror = (f) => {
+            if (d)
+              return i(f);
+            f.preventDefault(), p.continue();
+          };
+        } catch (l) {
+          if (d)
+            return n.abort(), i(l);
+          p.continue();
+        }
+      }, a.onerror = (h) => {
+        if (d)
+          return i(h);
+        h.preventDefault(), u(c);
+      };
+    });
+  }
+  async deleteOne(t, e) {
+    return this.deleteMany(t, { ...e, deleteLimit: 1 });
+  }
+  async findByIdAndDelete(t, e) {
+    const {
+      storeName: r,
+      transaction: n,
+      Constructor: o,
+      throwOnError: d = !0
+    } = e, c = n.objectStore(r);
+    return new Promise((u, i) => {
+      const a = c.get(t);
+      a.onsuccess = async (h) => {
+        let p;
+        if (h.target && "result" in h.target && (p = h.target.result), !p) {
+          u(p);
+          return;
+        }
+        p = o ? await o.preProcess(p, e) : p, p = o ? new o(p) : p;
+        try {
+          const l = c.delete(t);
+          l.onsuccess = () => {
+            u(p);
+          }, l.onerror = (f) => {
+            if (d)
+              return i(f);
+            f.preventDefault(), u(void 0);
+          };
+        } catch {
+          if (d)
+            return n.abort(), i(h);
+          u(void 0);
+        }
+      }, a.onerror = (h) => {
+        if (d)
+          return i(h);
+        h.preventDefault(), u(void 0);
+      };
+    });
+  }
+  async findByIdAndUpdate(t, e, r) {
+    const {
+      storeName: n,
+      transaction: o,
+      Constructor: d,
+      throwOnError: c = !0,
+      new: u = !0
+    } = r, i = o.objectStore(n);
+    return new Promise((a, h) => {
+      const p = i.get(t);
+      p.onsuccess = (l) => {
+        let f;
+        if (l.target && "result" in l.target && (f = l.target.result), !f) {
+          a(f);
+          return;
+        }
+        try {
+          const N = D(e) ? e(f) : E(f, e), v = i.put(N);
+          v.onsuccess = async () => {
+            let m = f;
+            u && (m = N), m = d ? await d.preProcess(m, r) : m, a(d ? new d(m) : m);
+          }, v.onerror = (m) => {
+            if (c)
+              return h(m);
+            m.preventDefault(), a(void 0);
+          };
+        } catch {
+          if (c)
+            return o.abort(), h(l);
+          a(void 0);
+        }
+      }, p.onerror = (l) => {
+        if (c)
+          return h(l);
+        l.preventDefault(), a(void 0);
+      };
+    });
+  }
+  async countDocuments(t, e) {
+    return new Promise((r, n) => {
+      const { storeName: o, transaction: d, throwOnError: c } = e;
+      let u = 0;
+      const i = d.objectStore(o).openCursor(t.$key);
+      i.onsuccess = function() {
+        const a = this.result;
+        if (!a || !a.value) {
+          r(u);
+          return;
+        }
+        b(t, a.value) && ++u, a.continue();
+      }, i.onerror = (a) => {
+        c ? n(a) : (a.preventDefault(), r(void 0));
+      };
+    });
+  }
+}
+class y {
+  static executor;
+  static getInstance() {
+    return this.executor || (this.executor = new M()), this.executor;
+  }
+}
+class w {
+  idb;
+  storeName;
+  options;
+  /**
+   *
+   * @param idb - Instance of the IndexedDB database
+   * @param storeName - Query operations will be performed on store object that having this store name
+   */
+  constructor(t, e) {
+    this.idb = t, this.storeName = e;
+  }
+  /**
+   * Opens a iterable cursor, with the cursor object it's possible to iterate one document after another
+   *
+   * @example
+   * ```ts
+   * const query = new Query(idb, "store-name");
+   * const itr = await query.openCursor({ $key: "text", value: { $gte: 4 } });
+   *
+   * for await (const doc of itr) {
+   *   console.log(doc);
+   * }
+   * ```
+   *
+   * @param query - Search query object
+   * @param options - Query options
+   * @returns
+   */
+  openCursor(t = { $key: null }, e = {}) {
+    return this.options = { type: "_openCursor", query: t, execOptions: e }, this;
+  }
+  _openCursor() {
+    if (this.options?.type !== "_openCursor")
+      throw new Error("Invalid openCursor method options");
+    const { query: t, execOptions: e } = this.options;
+    let r = e?.transaction;
+    return r || (r = this.idb.transaction(this.storeName, "readonly")), y.getInstance().openCursor(t, {
+      ...e,
+      idb: this.idb,
+      transaction: r,
+      storeName: this.storeName
+    });
+  }
+  /**
+   * Finds list of item from the IndexedDB
+   *
+   * @example
+   * ```ts
+   * const query = new Query(idb, "store-name");
+   * const data = await query.find({ $key: "text" });
+   * ```
+   *
+   * @param query - Search query object
+   * @param options - Query options
+   *
+   * @returns
+   */
+  find(t = { $key: null }, e = {}) {
+    return this.options = { type: "_find", query: t, execOptions: e }, this;
+  }
+  async _find() {
+    if (this.options?.type !== "_find")
+      throw new Error("Invalid find method options");
+    const { query: t, execOptions: e } = this.options;
+    let r = e?.transaction;
+    return r || (r = this.idb.transaction(this.storeName, "readonly")), y.getInstance().find(t, {
+      ...e,
+      idb: this.idb,
+      transaction: r,
+      storeName: this.storeName
+    });
+  }
+  /**
+   * Finds single item from the IndexedDB
+   *
+   * @example
+   * ```ts
+   * const query = new Query(idb, "store-name");
+   * const item = await query.findById("id");
+   * ```
+   *
+   * @param id - Search id
+   * @param options - Query options
+   * @returns
+   */
+  findById(t, e = {}) {
+    return this.options = {
+      type: "_findById",
+      query: { $key: t },
+      execOptions: e
+    }, this;
+  }
+  async _findById() {
+    if (this.options?.type !== "_findById")
+      throw new Error("Invalid findById method options");
+    if (!this.options.query.$key)
+      throw new Error("search key is required");
+    const { query: t, execOptions: e } = this.options;
+    let r = e.transaction;
+    return r || (r = this.idb.transaction(this.storeName, "readonly")), y.getInstance().findById(t.$key, {
+      ...e,
+      idb: this.idb,
+      transaction: r,
+      storeName: this.storeName
+    });
+  }
+  /**
+   * Inserts a single Document into IndexedDB object store
+   *
+   * @example
+   * ```ts
+   * const query = new Query(idb, "store-name");
+   * await query.insertOne(document, options);
+   * ```
+   *
+   * @param payload - Document to insert
+   * @param options - Query options
+   * @returns
+   */
+  insertOne(t, e = {}) {
+    return this.options = {
+      type: "_insertOne",
+      insertList: [t],
+      execOptions: e
+    }, this;
+  }
+  async _insertOne() {
+    if (this.options?.type !== "_insertOne")
+      throw new Error("Invalid insertOne method options");
+    const t = this.options.insertList[0];
+    if (!t)
+      throw new Error(
+        "At least one document is required to perform insertOne operations"
+      );
+    this.options.insertList = [];
+    let e = this.options.execOptions.transaction;
+    return e || (e = this.idb.transaction(this.storeName, "readwrite")), y.getInstance().insertOne(t, {
+      idb: this.idb,
+      transaction: e,
+      storeName: this.storeName
+    });
+  }
+  /**
+   * Inserts multiple documents into IndexedDB object store
+   *
+   * @example
+   * ```ts
+   * const query = new Query(idb, "store-name");
+   * await query.insertMany([document1, document2, ...], options);
+   * ```
+   *
+   * @remarks
+   * Insertion operation done using a single transaction,
+   * by default when error is thrown during a document insert the entire transaction will not be aborted.
+   * This behavior can be changed using the throwOnError option
+   *
+   * @param payload - Array of documents
+   * @param options - Query options
+   * @returns
+   */
+  insertMany(t, e = {}) {
+    return this.options = {
+      type: "_insertMany",
+      insertList: t,
+      execOptions: e
+    }, this;
+  }
+  async _insertMany() {
+    if (this.options?.type !== "_insertMany")
+      throw new Error("Invalid insertMany method options");
+    const t = this.options.insertList.slice();
+    this.options.insertList = [];
+    let e = this.options.execOptions.transaction;
+    return e || (e = this.idb.transaction(this.storeName, "readwrite")), y.getInstance().insertMany(t, {
+      idb: this.idb,
+      transaction: e,
+      storeName: this.storeName,
+      throwOnError: this.options.execOptions.throwOnError
+    });
+  }
+  /**
+   * To replace existing document with new document, if key is not present new document will be inserted
+   *
+   * @example
+   * ```ts
+   * const query = new Query(idb, "store-name");
+   * await query.replaceOne({ $key: key }, newDoc, options);
+   * ```
+   *
+   * @param payload - Document object to override
+   * @param options - Query options
+   * @returns
+   */
+  replaceOne(t, e = {}) {
+    return this.options = {
+      type: "_replaceOne",
+      payload: t,
+      execOptions: {
+        ...e
+      }
+    }, this;
+  }
+  async _replaceOne() {
+    if (this.options?.type !== "_replaceOne")
+      throw new Error("Invalid replaceOne method options");
+    const { payload: t, execOptions: e } = this.options;
+    let r = e.transaction;
+    return r || (r = this.idb.transaction(this.storeName, "readwrite")), y.getInstance().replaceOne(t, {
+      ...e,
+      idb: this.idb,
+      storeName: this.storeName,
+      transaction: r
+    });
+  }
+  /**
+   * Based on the query, matched documents will be updated
+   *
+   * @example
+   * ```ts
+   * const query = new Query(idb, "store-name");
+   * await query.updateMany({ $key: keyRange }, newDoc, options);
+   * ```
+   *
+   * @param query - Update query to find match
+   * @param payload - Callback to update the found document
+   * @param options - Query options
+   * @returns
+   */
+  updateMany(t, e, r = {}) {
+    return this.options = {
+      type: "_updateMany",
+      query: t,
+      payload: e,
+      execOptions: r
+    }, this;
+  }
+  async _updateMany() {
+    if (this.options?.type !== "_updateMany")
+      throw new Error("Invalid updateMany method options");
+    const { query: t, payload: e, execOptions: r } = this.options;
+    let n = r.transaction;
+    return n || (n = this.idb.transaction(this.storeName, "readwrite")), y.getInstance().updateMany(t, e, {
+      ...r,
+      idb: this.idb,
+      storeName: this.storeName,
+      transaction: n
+    });
+  }
+  /**
+   * Based on the query, first matched document will be updated
+   *
+   * @example
+   * ```ts
+   * const query = new Query(idb, "store-name");
+   * await query.updateOne({ $key: key }, newDoc, options);
+   * ```
+   *
+   * @param query - Update query to find match
+   * @param payload - New document or Callback to update the found document
+   * @param options - Query options
+   * @returns
+   */
+  updateOne(t, e, r = {}) {
+    return this.options = {
+      type: "_updateOne",
+      query: t,
+      payload: e,
+      execOptions: r
+    }, this;
+  }
+  async _updateOne() {
+    if (this.options?.type !== "_updateOne")
+      throw new Error("Invalid updateOne method options");
+    const { query: t, payload: e, execOptions: r } = this.options;
+    let n = r.transaction;
+    return n || (n = this.idb.transaction(this.storeName, "readwrite")), y.getInstance().updateOne(t, e, {
+      ...r,
+      idb: this.idb,
+      storeName: this.storeName,
+      transaction: n
+    });
+  }
+  /**
+   * Deletes all matched documents
+   *
+   * @example
+   * ```ts
+   * const query = new Query(idb, "store-name");
+   * await query.deleteMany({ $key: key }, options);
+   * ```
+   *
+   * @param query - Delete query to match documents
+   * @param options - Query options
+   * @returns
+   */
+  deleteMany(t = { $key: null }, e = {}) {
+    return this.options = {
+      type: "_deleteMany",
+      query: t,
+      execOptions: e
+    }, this;
+  }
+  async _deleteMany() {
+    if (this.options?.type !== "_deleteMany")
+      throw new Error("Invalid deleteMany method options");
+    const { query: t, execOptions: e } = this.options;
+    let r = e.transaction;
+    return r || (r = this.idb.transaction(this.storeName, "readwrite")), y.getInstance().deleteMany(t, {
+      ...e,
+      idb: this.idb,
+      storeName: this.storeName,
+      transaction: r
+    });
+  }
+  /**
+   * Based on the query, first matched document will be deleted
+   *
+   * @example
+   * ```ts
+   * const query = new Query(idb, "store-name");
+   * await query.deleteOne({ $key: key }, options);
+   * ```
+   *
+   * @remarks
+   * This is similar to calling the `deleteMany` with `deleteLimit = 1` option
+   *
+   * @param query - Delete query to match documents
+   * @param options - Query options
+   * @returns
+   */
+  deleteOne(t = { $key: null }, e = {}) {
+    return this.options = {
+      type: "_deleteOne",
+      query: t,
+      execOptions: e
+    }, this;
+  }
+  async _deleteOne() {
+    if (this.options?.type !== "_deleteOne")
+      throw new Error("Invalid deleteOne method options");
+    const { query: t, execOptions: e } = this.options;
+    let r = e.transaction;
+    return r || (r = this.idb.transaction(this.storeName, "readwrite")), y.getInstance().deleteOne(t, {
+      ...e,
+      idb: this.idb,
+      storeName: this.storeName,
+      transaction: r
+    });
+  }
+  /**
+   * Removes the document with the id and returnes the deleted document.
+   * if the document is not present `undefined` will be returned
+   *
+   * @example
+   * ```ts
+   * const query = new Query(idb, "store-name");
+   * const deletedDoc = await query.findByIdAndDelete(id, options);
+   * ```
+   *
+   * @param id - Valid search key to find a document
+   * @param options - Query options
+   * @returns
+   */
+  findByIdAndDelete(t, e = {}) {
+    return this.options = {
+      type: "_findByIdAndDelete",
+      id: t,
+      execOptions: e
+    }, this;
+  }
+  async _findByIdAndDelete() {
+    if (this.options?.type !== "_findByIdAndDelete")
+      throw new Error("Invalid findByIdAndDelete method options");
+    const { id: t, execOptions: e } = this.options;
+    let r = e.transaction;
+    return r || (r = this.idb.transaction(this.storeName, "readwrite")), y.getInstance().findByIdAndDelete(
+      t,
+      {
+        ...e,
+        idb: this.idb,
+        storeName: this.storeName,
+        transaction: r
+      }
+    );
+  }
+  /**
+   * Updates the document with the id and returns the updated document.
+   * if the document is not present `undefined` will be returned
+   *
+   * @example
+   * ```ts
+   * const query = new Query(idb, "store-name");
+   * const updatedDoc = await query.findByIdAndUpdate(
+   *  id,
+   *  (oldDoc) => newDoc,
+   *  options
+   * );
+   * ```
+   *
+   * @param id - Valid search key to find a document
+   * @param payload - Callback to update the found document
+   * @param options - Query options
+   * @returns
+   */
+  findByIdAndUpdate(t, e, r = {}) {
+    return this.options = {
+      type: "_findByIdAndUpdate",
+      id: t,
+      payload: e,
+      execOptions: r
+    }, this;
+  }
+  async _findByIdAndUpdate() {
+    if (this.options?.type !== "_findByIdAndUpdate")
+      throw new Error("Invalid findByIdAndUpdate method options");
+    const { id: t, payload: e, execOptions: r } = this.options;
+    let n = r.transaction;
+    return n || (n = this.idb.transaction(this.storeName, "readwrite")), y.getInstance().findByIdAndUpdate(t, e, {
+      ...r,
+      idb: this.idb,
+      storeName: this.storeName,
+      transaction: n
+    });
+  }
+  /**
+   * Returns the documents count that matches the search query
+   *
+   * @example
+   * ```ts
+   * const query = new Query(idb, "store-name");
+   * const count = await query.countDocuments(
+   *  query,
+   *  options
+   * );
+   * ```
+   *
+   * @param query - Search query
+   * @param options - Query options
+   * @returns
+   */
+  countDocuments(t = { $key: null }, e = {}) {
+    return this.options = {
+      type: "_countDocuments",
+      query: t,
+      execOptions: e
+    }, this;
+  }
+  async _countDocuments() {
+    if (this.options?.type !== "_countDocuments")
+      throw new Error("Invalid countDocuments method options");
+    const { query: t, execOptions: e } = this.options;
+    let r = e.transaction;
+    return r || (r = this.idb.transaction(this.storeName, "readonly")), y.getInstance().countDocuments(
+      t,
+      {
+        ...e,
+        idb: this.idb,
+        storeName: this.storeName,
+        transaction: r
+      }
+    );
+  }
+  populate(t) {
+    return (this.options?.type === "_find" || this.options?.type === "_findById" || this.options?.type === "_findByIdAndUpdate" || this.options?.type === "_findByIdAndDelete") && (this.options.execOptions.populateFields = this.options.execOptions.populateFields || {}, typeof t == "string" ? this.options.execOptions.populateFields[t] = { path: t } : this.options.execOptions.populateFields[t.path] = t), this;
+  }
+  /**
+   * Executes the query with accumulated options
+   *
+   * @example
+   * ```ts
+   * const query = new Query(idb, "store-name");
+   * const item = await query.findById("id").exec();
+   * ```
+   *
+   * @returns
+   */
+  async exec() {
+    if (!this.options?.type)
+      throw new Error(
+        "Once of the query operations must be called before calling exec"
+      );
+    return this[this.options.type]();
+  }
+  then(t, e) {
+    return this.exec().then(t, e);
+  }
+}
+const g = {}, F = class S {
+  // instance properties and methods
+  constructor(t) {
+    if (t && typeof t == "object")
+      for (const e in t)
+        this[e] = t[e];
+  }
+  async save() {
+    return this.validate(), await this.getInstanceSchema().save(this, {
+      modelInstance: this
+    }), new w(
+      this.getInstanceDB(),
+      this.getInstanceStoreName()
+    ).replaceOne(this.toJSON());
+  }
+  validate() {
+    return this.getInstanceSchema().validate(this, {
+      modelInstance: this
+    });
+  }
+  toJSON() {
+    return this.getInstanceSchema().castFrom(this);
+  }
+  getInstanceSchema() {
+    return S.getSchema(this);
+  }
+  getInstanceDB() {
+    return S.getDB(this);
+  }
+  getInstanceStoreName() {
+    return S.getStoreName(this);
+  }
+  // static properties and methods
+  static _schema;
+  static _storeName;
+  static _db;
+  static getSchema(t) {
+    const r = (t ? Object.getPrototypeOf(t).constructor : this)._schema;
+    if (!r)
+      throw new Error("Schema is required");
+    return r;
+  }
+  static getDB(t) {
+    const r = (t ? Object.getPrototypeOf(t).constructor : this)._db;
+    if (!r)
+      throw new Error("db is required");
+    return r;
+  }
+  static setDB(t) {
+    this._db = t;
+  }
+  static getStoreName(t) {
+    const r = (t ? Object.getPrototypeOf(t).constructor : this)._storeName;
+    if (!r)
+      throw new Error("db is required");
+    return r;
+  }
+  static init(t) {
+    this.setDB(t);
+  }
+  static onUpgradeNeeded(t) {
+    this._storeName && !t.objectStoreNames.contains(this._storeName) && t.createObjectStore(this._storeName, {
+      keyPath: "_id"
+    });
+  }
+  static async preProcess(t, e) {
+    return !t || typeof t != "object" ? t : this.getSchema().preProcess(t, e);
+  }
+  static createTransaction(t) {
+    return this.getDB().transaction(
+      [this.getStoreName(), ...this.getSchema().getRefNames()],
+      t
+    );
+  }
   /**
    * Model find method that overrieds the IQuery find method
    * @returns empty array
    */
-  find() {
-    return console.log("finding with update for browser IModel..."), [];
+  static find(t) {
+    return new w(this.getDB(), this.getStoreName()).find(
+      t,
+      {
+        Constructor: this,
+        transaction: this.createTransaction("readonly")
+      }
+    );
+  }
+  static findById(t) {
+    return new w(this.getDB(), this.getStoreName()).findById(t, {
+      Constructor: this,
+      transaction: this.createTransaction("readonly")
+    });
+  }
+  static findByIdAndUpdate(t, e, r) {
+    return new w(
+      this.getDB(),
+      this.getStoreName()
+    ).findByIdAndUpdate(t, e, {
+      Constructor: this,
+      transaction: this.createTransaction("readwrite"),
+      ...r
+    });
+  }
+  static findByIdAndDelete(t) {
+    return new w(
+      this.getDB(),
+      this.getStoreName()
+    ).findByIdAndDelete(t, {
+      Constructor: this,
+      transaction: this.createTransaction("readwrite")
+    });
+  }
+  static deleteOne(t) {
+    return new w(this.getDB(), this.getStoreName()).deleteOne(
+      t,
+      {
+        transaction: this.createTransaction("readwrite")
+      }
+    );
+  }
+};
+function T(s, t) {
+  class e extends F {
+  }
+  return e._schema = t.clone(), e._storeName = s, g[s] = e;
+}
+class A {
+  message;
+  constructor(t) {
+    this.message = t.message;
+  }
+}
+class k extends A {
+  validate(t) {
+    if (t == null || t === "")
+      throw new Error(this.message);
+    return !0;
+  }
+}
+class I {
+  name;
+  isVirtual;
+  validationRules;
+  constructor({
+    name: t,
+    isVirtual: e = !1,
+    validationRules: r = [],
+    required: n
+  } = {}) {
+    this.name = t, this.isVirtual = e, this.validationRules = r, n && this.validationRules.push(
+      new k({ message: `${t} is required!` })
+    );
+  }
+  clone() {
+    return null;
+  }
+  getIsVirtual() {
+    return this.isVirtual;
+  }
+  async preProcess(t, e) {
+    return this.name ? t[this.name] : t;
+  }
+  async save(t, e) {
+  }
+  validate(t, e) {
+    const r = this.castFrom(t);
+    return this.validationRules.forEach((n) => n.validate(r, e)), !0;
+  }
+}
+class R extends I {
+  valueSchema;
+  constructor(t) {
+    super(t), this.valueSchema = t.valueSchema;
+  }
+  validate(t, e) {
+    const r = this.castFrom(t);
+    return this.validationRules.forEach((n) => n.validate(r, e)), r && r.forEach((n) => {
+      this.valueSchema.validate(n, e);
+    }), !0;
+  }
+  castFrom(t) {
+    if (t == null) return t;
+    if (!Array.isArray(t))
+      throw new Error("cant cast to a array");
+    return t.map((e) => this.valueSchema.castFrom(e));
+  }
+}
+class $ extends I {
+  ref;
+  valueSchema;
+  constructor(t) {
+    super(t), this.ref = t.ref, this.valueSchema = t.valueSchema;
+  }
+  validate(t, e) {
+    return t && typeof t == "object" && "_id" in t ? this.valueSchema.validate(t._id, e) : this.valueSchema.validate(t, e);
+  }
+  async save(t, e) {
+    if (!t || typeof t != "object") return;
+    if (!g[this.ref])
+      throw new Error(`Ref ${this.ref} model is not created`);
+    const r = t instanceof g[this.ref] ? t : new g[this.ref](t);
+    return r.validate(), r.save();
+  }
+  async preProcess(t, e) {
+    if (this.name && e.populateFields && e.populateFields[this.name]) {
+      let r = t[this.name];
+      if (typeof r == "string" || typeof r == "number") {
+        if (!g[this.ref])
+          throw new Error(`Ref ${this.ref} model is not created`);
+        return await new w(e.idb, this.ref).findById(r, {
+          Constructor: g[this.ref],
+          // need to remove the prefix for nested objects
+          // populateFields: options.populateFields,
+          transaction: e.transaction
+        });
+      }
+    }
+    return this.name ? t[this.name] : t;
+  }
+  castFrom(t) {
+    return t && typeof t == "object" && "_id" in t ? t._id && this.valueSchema.castFrom(t._id) : t && this.valueSchema.castFrom(t);
+  }
+}
+class U extends A {
+  min;
+  constructor(t) {
+    super(t), this.min = t.min;
+  }
+  validate(t) {
+    if (typeof t == "number" && t < this.min)
+      throw new Error(this.message);
+    return !0;
+  }
+}
+class B extends I {
+  constructor(t) {
+    super(t), typeof t.min == "number" && this.validationRules.push(
+      new U({
+        message: `${t.name} must be greater then or equal to ${t.min}`,
+        min: t.min
+      })
+    );
+  }
+  castFrom(t) {
+    if (t == null) return t;
+    if (typeof t != "number" || isNaN(t))
+      throw new Error("cant cast to a number");
+    return Number(t);
+  }
+}
+class _ extends I {
+  castFrom(t) {
+    return String(t);
+  }
+}
+class L extends $ {
+  validate(t, e) {
+    return this.validationRules.forEach((r) => r.validate(t, e)), Array.isArray(t) ? t.every((r) => super.validate(r, e)) : !0;
+  }
+  async save(t, e) {
+    if (Array.isArray(t))
+      return Promise.all(t.map((r) => super.save(r, e)));
+  }
+  async preProcess(t, e) {
+    const r = /* @__PURE__ */ new Set();
+    if (this.name && e.populateFields)
+      for (const o in e.populateFields)
+        (o == this.name || o.startsWith(`${this.name}.`)) && r.add(o);
+    const n = this.name ? t[this.name] : t;
+    return this.name && Array.isArray(n) && r.size > 0 ? await Promise.all(
+      n.map((o, d) => {
+        if (typeof o != "string" && typeof o != "number")
+          return o;
+        if (!g[this.ref])
+          throw new Error(`Ref ${this.ref} model is not created`);
+        return !r.has(this.name) && !r.has(`${this.name}.${d}`) ? o : new w(e.idb, this.ref).findById(o, {
+          Constructor: g[this.ref],
+          // need to remove the prefix for nested objects
+          // populateFields: options.populateFields,
+          transaction: e.transaction
+        });
+      })
+    ) : n;
+  }
+  castFrom(t) {
+    if (Array.isArray(t))
+      return t.map((e) => super.castFrom(e));
+  }
+}
+class x extends I {
+  refNames;
+  tree;
+  rawDefinition;
+  constructor(t) {
+    super(), this.rawDefinition = t, this.tree = {}, this.refNames = [];
+    for (let e in t)
+      "type" in this.rawDefinition[e] && (this.rawDefinition[e] = {
+        ...this.rawDefinition[e]
+      }), this.tree[e] = this.parseSchemaDefinition(e, t[e]);
+    this.tree._id || (this.tree._id = new _({ name: "_id", required: !0 }));
+  }
+  parseSchemaDefinition(t, e) {
+    const r = "type" in e ? e.type : e, n = {
+      name: t,
+      required: void 0
+    };
+    if ("type" in e && (n.required = e.required), r === String)
+      return "ref" in e && e.ref ? (this.refNames.push(e.ref), new $({
+        name: t,
+        ref: e.ref,
+        valueSchema: new _(n),
+        required: e.required
+      })) : new _(n);
+    if (r === Number) {
+      const o = n;
+      return "min" in e && (o.min = e.min), "ref" in e && e.ref ? (this.refNames.push(e.ref), new $({
+        name: t,
+        ref: e.ref,
+        valueSchema: new B(o),
+        required: e.required
+      })) : new B(o);
+    } else if (Array.isArray(r)) {
+      if (r.length === 0)
+        throw new Error("Array type must have a value type");
+      return "ref" in r[0] && r[0].ref ? (this.refNames.push(r[0].ref), new L({
+        name: t,
+        ref: r[0].ref,
+        valueSchema: this.parseSchemaDefinition(t, r[0].type),
+        required: r[0].required
+      })) : new R({
+        valueSchema: this.parseSchemaDefinition(t, r[0]),
+        ...n
+      });
+    } else if (r instanceof x)
+      return r.clone();
+    throw new Error(`Type for ${t} is not supported`);
+  }
+  getRefNames() {
+    return this.refNames;
+  }
+  clone() {
+    return new x(
+      this.rawDefinition
+    );
+  }
+  async save(t, e) {
+    if (!t || typeof t != "object")
+      throw new Error("value must be an Object");
+    for (const r in this.tree)
+      await this.tree[r].save(t[r], e);
+  }
+  validate(t, e) {
+    if (!t || typeof t != "object")
+      throw new Error("value must be an Object");
+    for (const r in this.tree)
+      this.tree[r].validate(t[r], e);
+    return !0;
+  }
+  async preProcess(t, e) {
+    const r = {};
+    for (const n in t)
+      this.tree[n] && (r[n] = await this.tree[n].preProcess(t, e));
+    return r;
+  }
+  castFrom(t) {
+    if (!t || typeof t != "object")
+      throw new Error("Cant cast value to object schema");
+    const e = {};
+    for (const r in this.tree)
+      e[r] = this.tree[r].castFrom(t[r]);
+    return e;
   }
 }
-const d = (o, e) => o + e;
+const V = async (s) => {
+  const { models: t, db: e, version: r, onupgradeneeded: n } = s;
+  return new Promise((o, d) => {
+    const c = indexedDB.open(e, r);
+    c.onerror = d, c.onsuccess = function() {
+      t.forEach((u) => {
+        u.init(this.result);
+      }), o(this.result);
+    }, c.onupgradeneeded = function() {
+      t.forEach((u) => {
+        u.onUpgradeNeeded(this.result);
+      }), n && n(this);
+    };
+  });
+};
 export {
-  r as IModel,
-  d as add
+  F as AbstractModel,
+  x as Schema,
+  V as configureIDB,
+  T as model
 };