document-dataply 0.0.2-alpha.0 → 0.0.2-alpha.2

package/dist/cjs/index.js

@@ -7225,6 +7225,7 @@ var DocumentDataply = class {
     lte: "primaryLte",
     gt: "primaryGt",
     gte: "primaryGte",
+    or: "primaryOr",
     like: "like"
   };
   constructor(file, options) {
@@ -7253,7 +7254,7 @@ var DocumentDataply = class {
     for (const field in query) {
       const conditions = query[field];
       let newConditions;
-      if (typeof conditions !== "object") {
+      if (typeof conditions !== "object" || conditions === null) {
         newConditions = { primaryEqual: { v: conditions } };
       } else {
         newConditions = {};
@@ -7262,7 +7263,11 @@ var DocumentDataply = class {
           const after = this.operatorConverters[before];
           const v = conditions[before];
           if (!after) continue;
-          newConditions[after] = { v };
+          if (before === "or" && Array.isArray(v)) {
+            newConditions[after] = v.map((val) => ({ v: val }));
+          } else {
+            newConditions[after] = { v };
+          }
         }
       }
       result[field] = newConditions;
@@ -7282,7 +7287,10 @@ var DocumentDataply = class {
       const condition = query[field];
       candidates.push({ tree, condition });
     }
-    const res = import_dataply3.BPTreeAsync.ChooseDriver(candidates);
+    let res = import_dataply3.BPTreeAsync.ChooseDriver(candidates);
+    if (!res && candidates.length > 0) {
+      res = candidates[0];
+    }
     if (!res) return null;
     return {
       driver: {
@@ -7336,30 +7344,42 @@ var DocumentDataply = class {
       const verbose = this.verboseQuery(query);
       const selectivity = await this.getSelectivityCandidate(verbose);
       if (!selectivity) return [];
-      const keys = /* @__PURE__ */ new Set();
+      const documents = [];
       const { driver, others } = selectivity;
-      const stream = driver.tree.whereStream(driver.condition);
+      const stream = driver.condition.primaryOr ? (async function* () {
+        const values = driver.condition.primaryOr;
+        for (const val of values) {
+          const nodes = await driver.tree.where({ primaryEqual: val });
+          for (const [pk, node] of nodes) {
+            yield [pk, node];
+          }
+        }
+      })() : driver.condition.primaryNotEqual ? (async function* (api) {
+        const idTree = await api.ensureTree("_id");
+        const nodes = idTree.whereStream({ primaryGte: { v: 0 } });
+        for await (const [pk, node] of nodes) {
+          yield [pk, node];
+        }
+      })(this.api) : driver.tree.whereStream(driver.condition);
       for await (const [pk, val] of stream) {
+        const stringify = await this.api.select(pk, false, tx2);
+        if (!stringify) continue;
+        const doc = JSON.parse(stringify);
+        const flattenedDoc = this.api.flattenDocument(doc);
         let isMatch = true;
-        for (const { tree, condition } of others) {
-          const targetValue = await tree.get(pk);
-          if (targetValue === void 0 || !tree.verify(targetValue, condition)) {
+        const verificationList = driver.condition.primaryNotEqual ? [...others, driver] : others;
+        for (const { tree, condition } of verificationList) {
+          const field = tree.strategy.treeKey;
+          const fieldValue = flattenedDoc[field];
+          if (!tree.verify({ k: pk, v: fieldValue }, condition)) {
             isMatch = false;
             break;
           }
         }
         if (isMatch) {
-          keys.add(pk);
-          if (keys.size >= limit) break;
-        }
-      }
-      const documents = [];
-      for (const key of keys) {
-        const stringify = await this.api.select(key, false, tx2);
-        if (!stringify) {
-          continue;
+          documents.push(doc);
+          if (documents.length >= limit) break;
         }
-        documents.push(JSON.parse(stringify));
       }
       return documents;
     }, tx);

package/dist/types/types/index.d.ts

@@ -43,9 +43,12 @@ export type DocumentDataplyCondition<V> = {
     equal?: Partial<V>;
     notEqual?: Partial<V>;
     like?: Partial<V>;
+    or?: Partial<V>[];
 };
 export type DocumentDataplyQuery<T> = {
-    [key in keyof T]: T[key] | DocumentDataplyCondition<T[key]>;
+    [key in keyof T]?: T[key] | DocumentDataplyCondition<T[key]>;
+} & {
+    [key: string]: any;
 };
 export interface DataplyTreeValue<T> {
     k: number;
@@ -54,13 +57,21 @@ export interface DataplyTreeValue<T> {
 /**
  * T가 객체인지 확인하고, 객체라면 하위 키를 재귀적으로 탐색합니다.
  */
-type DeepFlattenKeys<T, Prefix extends string = ""> = T extends object ? {
-    [K in keyof T & string]: NonNullable<T[K]> extends object ? DeepFlattenKeys<NonNullable<T[K]>, `${Prefix}${K}.`> : `${Prefix}${K}`;
-}[keyof T & string] : Prefix extends `${infer P}.` ? P : "";
+type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20];
+/**
+ * T가 객체인지 확인하고, 객체라면 하위 키를 재귀적으로 탐색합니다.
+ * Depth 제한을 두어 "Type instantiation is excessively deep and possibly infinite" 에러를 방지합니다.
+ */
+export type DeepFlattenKeys<T, Prefix extends string = "", D extends number = 12> = [
+    D
+] extends [0] ? never : T extends Primitive ? (Prefix extends `${infer P}.` ? P : never) : T extends readonly any[] ? ((Prefix extends `${infer P}.` ? P : never) | DeepFlattenKeys<T[number], `${Prefix}${number}.`, Prev[D]>) : T extends object ? {
+    [K in keyof T & string]: NonNullable<T[K]> extends Primitive ? `${Prefix}${K}` : `${Prefix}${K}` | DeepFlattenKeys<NonNullable<T[K]>, `${Prefix}${K}.`, Prev[D]>;
+}[keyof T & string] : never;
 /**
  * 경로 문자열(Path)을 기반으로 원본 객체(T)에서 타입을 찾아옵니다.
+ * 배열 인덱스 접근 허용 (ex: tags.0)
  */
-type GetTypeByPath<T, Path extends string> = Path extends `${infer Key}.${infer Rest}` ? Key extends keyof T ? GetTypeByPath<NonNullable<T[Key]>, Rest> : never : Path extends keyof T ? T[Path] : never;
+type GetTypeByPath<T, Path extends string> = T extends readonly (infer U)[] ? Path extends `${infer Key}.${infer Rest}` ? Key extends `${number}` ? GetTypeByPath<U, Rest> : Key extends keyof T ? GetTypeByPath<T[Key], Rest> : never : Path extends `${number}` ? U : Path extends keyof T ? T[Path] : never : Path extends `${infer Key}.${infer Rest}` ? Key extends keyof T ? GetTypeByPath<NonNullable<T[Key]>, Rest> : never : Path extends keyof T ? T[Path] : never;
 export type FinalFlatten<T> = {
     [P in DeepFlattenKeys<T>]: GetTypeByPath<T, P & string>;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "document-dataply",
-  "version": "0.0.2-alpha.0",
+  "version": "0.0.2-alpha.2",
   "description": "",
   "license": "MIT",
   "author": "izure <admin@izure.org>",